@opendaw/studio-core 0.0.22 → 0.0.24

package/dist/RecordingWorklet.js

@@ -1,44 +1,13 @@
-import { Arrays, assert, ByteArrayInput, isUndefined, Notifier, Option, Progress, Terminable, UUID } from "@opendaw/lib-std";
+import { ByteArrayInput, Notifier, Option, Progress, Terminable, Terminator, UUID } from "@opendaw/lib-std";
+import { BPMTools } from "@opendaw/lib-dsp";
+import { SamplePeaks } from "@opendaw/lib-fusion";
 import { mergeChunkPlanes, RingBuffer } from "@opendaw/studio-adapters";
-import { SamplePeaks, SamplePeakWorker } from "@opendaw/lib-fusion";
+import { SampleStorage } from "./samples/SampleStorage";
 import { RenderQuantum } from "./RenderQuantum";
 import { WorkerAgents } from "./WorkerAgents";
-import { SampleStorage } from "./samples/SampleStorage";
-import { BPMTools } from "@opendaw/lib-dsp";
-class PeaksWriter {
-    numChannels;
-    data;
-    stages;
-    dataOffset = 0;
-    shift = 7;
-    dataIndex;
-    numFrames = 0 | 0;
-    constructor(numChannels) {
-        this.numChannels = numChannels;
-        this.data = Arrays.create(() => new Int32Array(1 << 20), numChannels); // TODO auto-resize
-        this.dataIndex = new Int32Array(numChannels);
-        this.stages = [this];
-    }
-    get numPeaks() { return Math.ceil(this.numFrames / (1 << this.shift)); }
-    unitsEachPeak() { return 1 << this.shift; }
-    append(frames) {
-        for (let channel = 0; channel < this.numChannels; ++channel) {
-            const channelFrames = frames[channel];
-            assert(channelFrames.length === RenderQuantum, "Invalid number of frames.");
-            let min = Number.POSITIVE_INFINITY;
-            let max = Number.NEGATIVE_INFINITY;
-            for (let i = 0; i < RenderQuantum; ++i) {
-                const frame = channelFrames[i];
-                min = Math.min(frame, min);
-                max = Math.max(frame, max);
-            }
-            this.data[channel][this.dataIndex[channel]++] = SamplePeakWorker.pack(min, max);
-        }
-        this.numFrames += RenderQuantum;
-    }
-    nearest(_unitsPerPixel) { return this.stages.at(0) ?? null; }
-}
+import { PeaksWriter } from "./PeaksWriter";
 export class RecordingWorklet extends AudioWorkletNode {
+    #terminator = new Terminator();
     uuid = UUID.generate();
     #output;
     #notifier;
@@ -47,7 +16,7 @@ export class RecordingWorklet extends AudioWorkletNode {
     #data = Option.None;
     #peaks = Option.None;
     #isRecording = true;
-    #truncateLatency;
+    #limitSamples = Number.POSITIVE_INFINITY;
     #state = { type: "record" };
     constructor(context, config, outputLatency) {
         super(context, "recording-processor", {
@@ -56,31 +25,30 @@ export class RecordingWorklet extends AudioWorkletNode {
             channelCountMode: "explicit",
             processorOptions: config
         });
-        if (isUndefined(outputLatency)) {
-            // TODO Talk to the user
-            console.warn("outputLatency is undefined. Please use Chrome.");
-        }
         this.#peakWriter = new PeaksWriter(config.numberOfChannels);
-        this.#truncateLatency = Math.floor((outputLatency ?? 0) * this.context.sampleRate / RenderQuantum);
+        this.#peaks = Option.wrap(this.#peakWriter);
         this.#output = [];
         this.#notifier = new Notifier();
         this.#reader = RingBuffer.reader(config, array => {
             if (this.#isRecording) {
-                if (this.#truncateLatency === 0) {
-                    this.#output.push(array);
+                this.#output.push(array);
+                const latencyInSamples = (outputLatency * this.context.sampleRate) | 0;
+                if (this.numberOfFrames >= latencyInSamples) {
                     this.#peakWriter.append(array);
                 }
-                else {
-                    if (--this.#truncateLatency === 0) {
-                        this.#peaks = Option.wrap(this.#peakWriter);
-                    }
+                const need = this.numberOfFrames - latencyInSamples;
+                if (need >= this.#limitSamples) {
+                    this.#finalize().catch(error => console.warn(error));
                 }
             }
         });
     }
+    own(terminable) { return this.#terminator.own(terminable); }
+    limit(count) { this.#limitSamples = count; }
+    setFillLength(value) { this.#peakWriter.numFrames = value; }
     get numberOfFrames() { return this.#output.length * RenderQuantum; }
     get data() { return this.#data; }
-    get peaks() { return this.#peaks; }
+    get peaks() { return this.#peaks.isEmpty() ? Option.wrap(this.#peakWriter) : this.#peaks; }
     get state() { return this.#state; }
     invalidate() { }
     subscribe(observer) {
@@ -90,35 +58,41 @@ export class RecordingWorklet extends AudioWorkletNode {
         }
         return this.#notifier.subscribe(observer);
     }
-    async finalize() {
+    terminate() {
         this.#reader.stop();
         this.#isRecording = false;
+        this.#terminator.terminate();
+    }
+    toString() { return `{RecordingWorklet}`; }
+    async #finalize() {
+        this.#isRecording = false;
+        this.#reader.stop();
+        if (this.#output.length === 0) {
+            return;
+        }
+        const totalSamples = this.#limitSamples;
         const sample_rate = this.context.sampleRate;
-        const numberOfFrames = this.#output.length * RenderQuantum;
         const numberOfChannels = this.channelCount;
-        const frames = mergeChunkPlanes(this.#output, RenderQuantum, numberOfFrames);
+        const frames = mergeChunkPlanes(this.#output, RenderQuantum, this.#output.length * RenderQuantum)
+            .map(frame => frame.slice(-totalSamples));
         const audioData = {
             sampleRate: sample_rate,
             numberOfChannels,
-            numberOfFrames,
+            numberOfFrames: totalSamples,
             frames
         };
         this.#data = Option.wrap(audioData);
-        const shifts = SamplePeaks.findBestFit(numberOfFrames);
+        const shifts = SamplePeaks.findBestFit(totalSamples);
         const peaks = await WorkerAgents
-            .Peak.generateAsync(Progress.Empty, shifts, frames, numberOfFrames, numberOfChannels);
+            .Peak.generateAsync(Progress.Empty, shifts, frames, totalSamples, numberOfChannels);
         this.#peaks = Option.wrap(SamplePeaks.from(new ByteArrayInput(peaks)));
         const bpm = BPMTools.detect(frames[0], sample_rate);
-        const duration = numberOfFrames / sample_rate;
+        const duration = totalSamples / sample_rate;
         const meta = { name: "Recording", bpm, sample_rate, duration };
         await SampleStorage.store(this.uuid, audioData, peaks, meta);
         this.#setState({ type: "loaded" });
+        this.terminate();
     }
-    terminate() {
-        this.#reader.stop();
-        this.#isRecording = false;
-    }
-    toString() { return `{RecordingWorklet}`; }
     #setState(value) {
         this.#state = value;
         this.#notifier.notify(this.#state);

package/dist/capture/Capture.d.ts

@@ -1,17 +1,16 @@
 import { MutableObservableValue, Option, Terminable, UUID } from "@opendaw/lib-std";
 import { AudioUnitBox } from "@opendaw/studio-boxes";
 import { CaptureBox } from "@opendaw/studio-adapters";
-import { RecordingContext } from "./RecordingContext";
-import { CaptureManager } from "./CaptureManager";
+import { CaptureDevices } from "./CaptureDevices";
 export declare abstract class Capture<BOX extends CaptureBox = CaptureBox> implements Terminable {
     #private;
-    protected constructor(manager: CaptureManager, audioUnitBox: AudioUnitBox, captureBox: BOX);
+    protected constructor(manager: CaptureDevices, audioUnitBox: AudioUnitBox, captureBox: BOX);
     abstract get label(): string;
     abstract get deviceLabel(): Option<string>;
-    abstract prepareRecording(context: RecordingContext): Promise<void>;
-    abstract startRecording(context: RecordingContext): Terminable;
+    abstract prepareRecording(): Promise<void>;
+    abstract startRecording(): Terminable;
     get uuid(): UUID.Format;
-    get manager(): CaptureManager;
+    get manager(): CaptureDevices;
     get audioUnitBox(): AudioUnitBox;
     get captureBox(): BOX;
     get armed(): MutableObservableValue<boolean>;

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

@@ -1 +1 @@
-{"version":3,"file":"Capture.d.ts","sourceRoot":"","sources":["../../src/capture/Capture.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,sBAAsB,EACtB,MAAM,EACN,UAAU,EAEV,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAA;AAClD,OAAO,EAAC,UAAU,EAAC,MAAM,0BAA0B,CAAA;AAEnD,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAE/C,8BAAsB,OAAO,CAAC,GAAG,SAAS,UAAU,GAAG,UAAU,CAAE,YAAW,UAAU;;IAUpF,SAAS,aAAa,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG;IAmB1F,QAAQ,KAAK,KAAK,IAAI,MAAM,CAAA;IAC5B,QAAQ,KAAK,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAAA;IAC1C,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IACnE,QAAQ,CAAC,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,UAAU;IAE9D,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,CAAyC;IAChE,IAAI,OAAO,IAAI,cAAc,CAAuB;IACpD,IAAI,YAAY,IAAI,YAAY,CAA4B;IAC5D,IAAI,UAAU,IAAI,GAAG,CAA0B;IAC/C,IAAI,KAAK,IAAI,sBAAsB,CAAC,OAAO,CAAC,CAAqB;IACjE,IAAI,QAAQ,IAAI,sBAAsB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAwB;IAE9E,GAAG,CAAC,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC;IAC3C,MAAM,CAAC,CAAC,SAAS,UAAU,EAAE,GAAG,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IACpE,SAAS,IAAI,IAAI;CACpB"}
+{"version":3,"file":"Capture.d.ts","sourceRoot":"","sources":["../../src/capture/Capture.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,sBAAsB,EACtB,MAAM,EACN,UAAU,EAEV,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAA;AAClD,OAAO,EAAC,UAAU,EAAC,MAAM,0BAA0B,CAAA;AACnD,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAE/C,8BAAsB,OAAO,CAAC,GAAG,SAAS,UAAU,GAAG,UAAU,CAAE,YAAW,UAAU;;IAUpF,SAAS,aAAa,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG;IAmB1F,QAAQ,KAAK,KAAK,IAAI,MAAM,CAAA;IAC5B,QAAQ,KAAK,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAAA;IAC1C,QAAQ,CAAC,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAC1C,QAAQ,CAAC,cAAc,IAAI,UAAU;IAErC,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,CAAyC;IAChE,IAAI,OAAO,IAAI,cAAc,CAAuB;IACpD,IAAI,YAAY,IAAI,YAAY,CAA4B;IAC5D,IAAI,UAAU,IAAI,GAAG,CAA0B;IAC/C,IAAI,KAAK,IAAI,sBAAsB,CAAC,OAAO,CAAC,CAAqB;IACjE,IAAI,QAAQ,IAAI,sBAAsB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAwB;IAE9E,GAAG,CAAC,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC;IAC3C,MAAM,CAAC,CAAC,SAAS,UAAU,EAAE,GAAG,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IACpE,SAAS,IAAI,IAAI;CACpB"}

package/dist/capture/CaptureAudio.d.ts

@@ -1,18 +1,17 @@
 import { MutableObservableOption, Option, Terminable } from "@opendaw/lib-std";
 import { AudioUnitBox, CaptureAudioBox } from "@opendaw/studio-boxes";
 import { Capture } from "./Capture";
-import { CaptureManager } from "./CaptureManager";
-import { RecordingContext } from "./RecordingContext";
+import { CaptureDevices } from "./CaptureDevices";
 export declare class CaptureAudio extends Capture<CaptureAudioBox> {
     #private;
-    constructor(manager: CaptureManager, audioUnitBox: AudioUnitBox, captureAudioBox: CaptureAudioBox);
+    constructor(manager: CaptureDevices, audioUnitBox: AudioUnitBox, captureAudioBox: CaptureAudioBox);
     get gainDb(): number;
     get stream(): MutableObservableOption<MediaStream>;
     get streamDeviceId(): Option<string>;
     get label(): string;
     get deviceLabel(): Option<string>;
     get streamMediaTrack(): Option<MediaStreamTrack>;
-    prepareRecording({}: RecordingContext): Promise<void>;
-    startRecording({ audioContext, worklets, project, sampleManager }: RecordingContext): Terminable;
+    prepareRecording(): Promise<void>;
+    startRecording(): Terminable;
 }
 //# sourceMappingURL=CaptureAudio.d.ts.map

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,EAAuC,uBAAuB,EAAE,MAAM,EAAE,UAAU,EAAO,MAAM,kBAAkB,CAAA;AAExH,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;AAE/C,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AAGnD,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,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAE3D,cAAc,CAAC,EAAC,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAC,EAAE,gBAAgB,GAAG,UAAU;CA6DjG"}
+{"version":3,"file":"CaptureAudio.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,uBAAuB,EACvB,MAAM,EAEN,UAAU,EAEb,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;IAcvC,cAAc,IAAI,UAAU;CA+D/B"}

package/dist/capture/CaptureAudio.js

@@ -1,4 +1,4 @@
-import { assert, isDefined, isUndefined, MutableObservableOption, Option, warn } from "@opendaw/lib-std";
+import { abort, isDefined, isUndefined, MutableObservableOption, Option, safeExecute, Terminable, warn } from "@opendaw/lib-std";
 import { Promises } from "@opendaw/lib-runtime";
 import { Capture } from "./Capture";
 import { RecordAudio } from "./RecordAudio";
@@ -39,14 +39,29 @@ export class CaptureAudio extends Capture {
     get streamMediaTrack() {
         return this.#stream.flatMap(stream => Option.wrap(stream.getAudioTracks().at(0)));
     }
-    async prepareRecording({}) { return this.#streamGenerator(); }
-    startRecording({ audioContext, worklets, project, sampleManager }) {
+    async prepareRecording() {
+        const { project } = this.manager;
+        const { env: { audioContext } } = project;
+        if (isUndefined(audioContext.outputLatency)) {
+            const approved = await safeExecute(project.env.dialogs?.approve, "Warning", "Your browser does not support 'output latency'. This will cause timing issue while recording.", "Ignore", "Cancel");
+            if (!approved) {
+                return abort("Recording cancelled");
+            }
+        }
+        return this.#streamGenerator();
+    }
+    startRecording() {
+        const { project } = this.manager;
+        const { env: { audioContext, audioWorklets, sampleManager } } = project;
         const streamOption = this.#stream;
-        assert(streamOption.nonEmpty(), "Stream not prepared.");
+        if (streamOption.isEmpty()) {
+            console.warn("No audio stream available for recording.");
+            return Terminable.Empty;
+        }
         const mediaStream = streamOption.unwrap();
         const channelCount = mediaStream.getAudioTracks().at(0)?.getSettings().channelCount ?? 1;
         const numChunks = 128;
-        const recordingWorklet = worklets.createRecording(channelCount, numChunks, audioContext.outputLatency);
+        const recordingWorklet = audioWorklets.createRecording(channelCount, numChunks, audioContext.outputLatency);
         return RecordAudio.start({
             recordingWorklet,
             mediaStream,
@@ -61,20 +76,16 @@ export class CaptureAudio extends Capture {
         if (this.#stream.nonEmpty()) {
             const stream = this.#stream.unwrap();
             const settings = stream.getAudioTracks().at(0)?.getSettings();
-            console.debug(stream.getAudioTracks());
             if (isDefined(settings)) {
                 const deviceId = this.deviceId.getValue().unwrapOrUndefined();
-                const channelCount = this.#requestChannels.unwrapOrElse(1);
-                const satisfyChannelCount = settings.channelCount === channelCount;
-                const satisfiedDeviceId = isUndefined(deviceId) || deviceId === settings.deviceId;
-                if (satisfiedDeviceId && satisfyChannelCount) {
+                if (isUndefined(deviceId) || deviceId === settings.deviceId) {
                     return Promise.resolve();
                 }
             }
         }
         this.#stopStream();
         const deviceId = this.deviceId.getValue().unwrapOrUndefined();
-        const channelCount = this.#requestChannels.unwrapOrElse(1); // as of today, browsers cap MediaStream audio to stereo.
+        const channelCount = this.#requestChannels.unwrapOrElse(1);
         return AudioDevices.requestStream({
             deviceId: { exact: deviceId },
             sampleRate: this.manager.project.engine.sampleRate(),
@@ -82,12 +93,13 @@ export class CaptureAudio extends Capture {
             echoCancellation: false,
             noiseSuppression: false,
             autoGainControl: false,
-            channelCount
+            channelCount: { ideal: channelCount }
         }).then(stream => {
             const tracks = stream.getAudioTracks();
-            const settings = tracks.at(0)?.getSettings();
+            const track = tracks.at(0);
+            const settings = track?.getSettings();
             const gotDeviceId = settings?.deviceId;
-            console.debug(`new stream id: ${stream.id}, device: ${gotDeviceId ?? "Default"}`);
+            console.debug(`new stream. device requested: ${stream.id}, got: ${gotDeviceId ?? "Default"}. channelCount requested: ${channelCount}, got: ${settings?.channelCount}`);
             if (isUndefined(deviceId) || deviceId === gotDeviceId) {
                 this.#stream.wrap(stream);
             }

package/dist/capture/{CaptureManager.d.ts → CaptureDevices.d.ts}

@@ -1,12 +1,13 @@
 import { Option, Terminable, UUID } from "@opendaw/lib-std";
-import { Project } from "../Project";
+import { Project } from "../project/Project";
 import { Capture } from "./Capture";
-export declare class CaptureManager implements Terminable {
+export declare class CaptureDevices implements Terminable {
     #private;
     constructor(project: Project);
     get project(): Project;
     get(uuid: UUID.Format): Option<Capture>;
+    setArm(subject: Capture, exclusive: boolean): void;
     filterArmed(): ReadonlyArray<Capture>;
     terminate(): void;
 }
-//# sourceMappingURL=CaptureManager.d.ts.map
+//# sourceMappingURL=CaptureDevices.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CaptureDevices.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureDevices.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,MAAM,EAA2B,UAAU,EAAE,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAEpH,OAAO,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAA;AAC1C,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAIjC,qBAAa,cAAe,YAAW,UAAU;;gBAKjC,OAAO,EAAE,OAAO;IAiB5B,IAAI,OAAO,IAAI,OAAO,CAAuB;IAE7C,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC;IAEvC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI;IAUlD,WAAW,IAAI,aAAa,CAAC,OAAO,CAAC;IAKrC,SAAS,IAAI,IAAI;CAKpB"}

package/dist/capture/{CaptureManager.js → CaptureDevices.js}

@@ -2,7 +2,7 @@ import { asInstanceOf, isDefined, UUID } from "@opendaw/lib-std";
 import { AudioUnitBox } from "@opendaw/studio-boxes";
 import { CaptureMidi } from "./CaptureMidi";
 import { CaptureAudio } from "./CaptureAudio";
-export class CaptureManager {
+export class CaptureDevices {
     #project;
     #subscription;
     #captures;
@@ -26,6 +26,15 @@ export class CaptureManager {
     }
     get project() { return this.#project; }
     get(uuid) { return this.#captures.opt(uuid); }
+    setArm(subject, exclusive) {
+        const arming = !subject.armed.getValue();
+        subject.armed.setValue(arming);
+        if (arming && exclusive) {
+            this.#captures.values()
+                .filter(capture => subject !== capture)
+                .forEach(capture => capture.armed.setValue(false));
+        }
+    }
     filterArmed() {
         return this.#captures.values()
             .filter(capture => capture.armed.getValue() && capture.audioUnitBox.input.pointerHub.nonEmpty());

package/dist/capture/CaptureMidi.d.ts

@@ -1,14 +1,16 @@
-import { Option, Terminable } from "@opendaw/lib-std";
+import { Observer, Option, Subscription, Terminable } from "@opendaw/lib-std";
 import { AudioUnitBox, CaptureMidiBox } from "@opendaw/studio-boxes";
+import { NoteSignal } from "@opendaw/studio-adapters";
 import { Capture } from "./Capture";
-import { RecordingContext } from "./RecordingContext";
-import { CaptureManager } from "./CaptureManager";
+import { CaptureDevices } from "./CaptureDevices";
 export declare class CaptureMidi extends Capture<CaptureMidiBox> {
     #private;
-    constructor(manager: CaptureManager, audioUnitBox: AudioUnitBox, captureMidiBox: CaptureMidiBox);
+    constructor(manager: CaptureDevices, audioUnitBox: AudioUnitBox, captureMidiBox: CaptureMidiBox);
+    notify(signal: NoteSignal): void;
+    subscribeNotes(observer: Observer<NoteSignal>): Subscription;
     get label(): string;
     get deviceLabel(): Option<string>;
-    prepareRecording({}: RecordingContext): Promise<void>;
-    startRecording({ project }: RecordingContext): Terminable;
+    prepareRecording(): Promise<void>;
+    startRecording(): Terminable;
 }
 //# sourceMappingURL=CaptureMidi.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"CaptureMidi.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureMidi.ts"],"names":[],"mappings":"AAAA,OAAO,EAQH,MAAM,EAEN,UAAU,EAEb,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAC,YAAY,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEjC,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAI/C,qBAAa,WAAY,SAAQ,OAAO,CAAC,cAAc,CAAC;;gBAQxC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc;IAsC/F,IAAI,KAAK,IAAI,MAAM,CAKlB;IAED,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAIhC;IAEK,gBAAgB,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB3D,cAAc,CAAC,EAAC,OAAO,EAAC,EAAE,gBAAgB,GAAG,UAAU;CA8C1D"}
+{"version":3,"file":"CaptureMidi.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureMidi.ts"],"names":[],"mappings":"AAAA,OAAO,EAOH,QAAQ,EACR,MAAM,EACN,YAAY,EACZ,UAAU,EAEb,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAC,YAAY,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAC,UAAU,EAAC,MAAM,0BAA0B,CAAA;AAEnD,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AACjC,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAG/C,qBAAa,WAAY,SAAQ,OAAO,CAAC,cAAc,CAAC;;gBAOxC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc;IA8B/F,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAEhC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,YAAY;IAE5D,IAAI,KAAK,IAAI,MAAM,CAgBlB;IAED,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAIhC;IAEK,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAuBvC,cAAc,IAAI,UAAU;CAgD/B"}

package/dist/capture/CaptureMidi.js

@@ -1,23 +1,26 @@
-import { asDefined, assert, isDefined, isUndefined, Notifier, Option, Terminable, warn } from "@opendaw/lib-std";
+import { assert, isDefined, isUndefined, Notifier, Option, Terminable, warn } from "@opendaw/lib-std";
 import { Events } from "@opendaw/lib-dom";
 import { MidiData } from "@opendaw/lib-midi";
+import { Promises } from "@opendaw/lib-runtime";
+import { NoteSignal } from "@opendaw/studio-adapters";
+import { MidiDevices } from "../MidiDevices";
 import { Capture } from "./Capture";
 import { RecordMidi } from "./RecordMidi";
-import { MidiDevices } from "../MidiDevices";
-import { Promises } from "@opendaw/lib-runtime";
 export class CaptureMidi extends Capture {
     #streamGenerator;
     #notifier = new Notifier();
     #filterChannel = Option.None;
-    #streaming = Option.None;
+    #stream = Option.None;
     constructor(manager, audioUnitBox, captureMidiBox) {
         super(manager, audioUnitBox, captureMidiBox);
         this.#streamGenerator = Promises.sequential(() => this.#updateStream());
-        this.ownAll(captureMidiBox.channel.subscribe(async (owner) => {
+        this.ownAll(captureMidiBox.channel.catchupAndSubscribe(async (owner) => {
             const channel = owner.getValue();
             this.#filterChannel = channel >= 0 ? Option.wrap(channel) : Option.None;
-            await this.#streamGenerator();
-        }), captureMidiBox.deviceId.catchupAndSubscribe(async () => {
+            if (this.armed.getValue()) {
+                await this.#streamGenerator();
+            }
+        }), captureMidiBox.deviceId.subscribe(async () => {
             if (this.armed.getValue()) {
                 await this.#streamGenerator();
             }
@@ -29,23 +32,27 @@ export class CaptureMidi extends Capture {
             else {
                 this.#stopStream();
             }
-        }), this.#notifier.subscribe(event => {
-            console.debug(MidiData.debug(event.data));
-            const data = asDefined(event.data);
-            const engine = manager.project.engine;
-            const isNoteOn = MidiData.isNoteOn(data);
-            if (MidiData.isNoteOff(data) || (isNoteOn && MidiData.readVelocity(data) === 0)) {
-                engine.noteOff(this.uuid, MidiData.readPitch(data));
-            }
-            else if (isNoteOn) {
-                engine.noteOn(this.uuid, MidiData.readPitch(data), MidiData.readVelocity(data));
-            }
-        }));
+        }), this.#notifier.subscribe((signal) => manager.project.engine.noteSignal(signal)));
     }
+    notify(signal) { this.#notifier.notify(signal); }
+    subscribeNotes(observer) { return this.#notifier.subscribe(observer); }
     get label() {
         return MidiDevices.get().mapOr(midiAccess => this.deviceId.getValue().match({
-            none: () => this.armed.getValue() ? "Listening to all MIDI devices" : "Idle",
-            some: value => `Listening to ${midiAccess.inputs.get(value)?.name}`
+            none: () => this.armed.getValue() ? this.#filterChannel.match({
+                none: () => `Listening to all devices`,
+                some: channel => `Listening to all devices on channel '${channel}'`
+            }) : "Arm to listen to MIDI device...",
+            some: id => {
+                const device = midiAccess.inputs.get(id);
+                if (isUndefined(device)) {
+                    return `⚠️ Could not find device with id '${id}'`;
+                }
+                const deviceName = device.name ?? "Unknown device";
+                return this.#filterChannel.match({
+                    none: () => `Listening to ${deviceName}`,
+                    some: channel => `Listening to ${deviceName} on channel '${channel}'`
+                });
+            }
         }), "MIDI not available");
     }
     get deviceLabel() {
@@ -53,64 +60,76 @@ export class CaptureMidi extends Capture {
             .flatMap(deviceId => MidiDevices.inputs()
             .map(inputs => inputs.find(input => input.id === deviceId)?.name));
     }
-    async prepareRecording({}) {
-        const availableMidiDevices = MidiDevices.get();
-        if (availableMidiDevices.isEmpty()) {
-            return Promise.reject("MIDI is not available");
+    async prepareRecording() {
+        if (MidiDevices.get().isEmpty()) {
+            if (MidiDevices.canRequestMidiAccess()) {
+                await MidiDevices.requestPermission();
+            }
+            else {
+                return warn("MIDI not available");
+            }
+        }
+        const optInputs = MidiDevices.inputs();
+        if (optInputs.isEmpty()) {
+            return warn("MIDI not available");
+        }
+        const inputs = optInputs.unwrap();
+        if (inputs.length === 0) {
+            return;
         }
         const option = this.deviceId.getValue();
         if (option.nonEmpty()) {
-            const { inputs } = availableMidiDevices.unwrap();
-            const captureDevices = Array.from(inputs.values());
             const deviceId = option.unwrap();
-            if (isUndefined(captureDevices.find(device => deviceId === device.id))) {
+            if (isUndefined(inputs.find(device => deviceId === device.id))) {
                 return warn(`Could not find MIDI device with id: '${deviceId}'`);
             }
         }
     }
-    startRecording({ project }) {
+    startRecording() {
         const availableMidiDevices = MidiDevices.inputs();
         assert(availableMidiDevices.nonEmpty(), "No MIDI input devices found");
-        return RecordMidi.start({ notifier: this.#notifier, project, capture: this });
+        return RecordMidi.start({ notifier: this.#notifier, project: this.manager.project, capture: this });
     }
     async #updateStream() {
-        // TODO Check if the requirements have been changed (are different than the current stream setup)
         if (MidiDevices.get().isEmpty()) {
             await MidiDevices.requestPermission();
         }
         const availableMidiDevices = MidiDevices.inputs();
-        const inputs = availableMidiDevices.unwrap();
-        const captureDevices = this.deviceId.getValue().match({
-            none: () => inputs,
-            some: id => inputs.filter(device => id === device.id)
+        const available = availableMidiDevices.unwrap();
+        const capturing = this.deviceId.getValue().match({
+            none: () => available,
+            some: id => available.filter(device => id === device.id)
         });
         const activeNotes = new Int8Array(128);
-        this.#streaming.ifSome(terminable => terminable.terminate());
-        this.#streaming = Option.wrap(Terminable.many(...captureDevices.map(input => Events.subscribe(input, "midimessage", (event) => {
+        this.#stream.ifSome(terminable => terminable.terminate());
+        this.#stream = Option.wrap(Terminable.many(...capturing.map(input => Events.subscribe(input, "midimessage", (event) => {
             const data = event.data;
             if (isDefined(data) &&
                 this.#filterChannel.mapOr(channel => MidiData.readChannel(data) === channel, true)) {
+                const pitch = MidiData.readPitch(data);
                 if (MidiData.isNoteOn(data)) {
-                    activeNotes[MidiData.readPitch(data)]++;
-                    this.#notifier.notify(event);
+                    activeNotes[pitch]++;
+                    this.#notifier.notify(NoteSignal.fromEvent(event, this.uuid));
                 }
-                else if (MidiData.isNoteOff(data)) {
-                    activeNotes[MidiData.readPitch(data)]--;
-                    this.#notifier.notify(event);
+                else if (MidiData.isNoteOff(data) && activeNotes[pitch] > 0) {
+                    activeNotes[pitch]--;
+                    this.#notifier.notify(NoteSignal.fromEvent(event, this.uuid));
                 }
             }
         })), Terminable.create(() => activeNotes.forEach((count, index) => {
             if (count > 0) {
-                // TODO respect channel!
-                const event = new MessageEvent("midimessage", { data: MidiData.noteOff(index, count) });
-                for (let i = 0; i < count; i++) {
-                    this.#notifier.notify(event);
+                for (let channel = 0; channel < 16; channel++) {
+                    const event = new MessageEvent("midimessage", { data: MidiData.noteOff(channel, index) });
+                    const signal = NoteSignal.fromEvent(event, this.uuid);
+                    for (let i = 0; i < count; i++) {
+                        this.#notifier.notify(signal);
+                    }
                 }
             }
         }))));
     }
     #stopStream() {
-        this.#streaming.ifSome(terminable => terminable.terminate());
-        this.#streaming = Option.None;
+        this.#stream.ifSome(terminable => terminable.terminate());
+        this.#stream = Option.None;
     }
 }

package/dist/capture/RecordAudio.d.ts

@@ -1,8 +1,8 @@
 import { Terminable } from "@opendaw/lib-std";
 import { SampleManager } from "@opendaw/studio-adapters";
-import { Project } from "../Project";
-import { Capture } from "./Capture";
+import { Project } from "../project/Project";
 import { RecordingWorklet } from "../RecordingWorklet";
+import { Capture } from "./Capture";
 export declare namespace RecordAudio {
     type RecordAudioContext = {
         recordingWorklet: RecordingWorklet;

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,EAAwB,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAGpF,OAAO,EAAC,aAAa,EAAY,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEjC,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAA;AAGpD,yBAAiB,WAAW,CAAC;IACzB,KAAK,kBAAkB,GAAG;QACtB,gBAAgB,EAAE,gBAAgB,CAAA;QAClC,WAAW,EAAE,WAAW,CAAA;QACxB,aAAa,EAAE,aAAa,CAAA;QAC5B,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,0FAEG,kBAAkB,KAAG,UA2D3B,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,EAAC,aAAa,EAAY,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAA;AAC1C,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,WAAW,EAAE,WAAW,CAAA;QACxB,aAAa,EAAE,aAAa,CAAA;QAC5B,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,UAqEL,CAAA;;CACJ"}