@opendaw/studio-core 0.0.87 → 0.0.89

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;QACd,aAAa,EAAE,MAAM,CAAA;KACxB,CAAA;IAQD,MAAM,CAAC,MAAM,KAAK,GACd,yGASG,kBAAkB,KACnB,UAsIL,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

@@ -23,6 +23,7 @@ export var RecordAudio;
         let currentTake = Option.None;
         let lastPosition = 0;
         let currentWaveformOffset = outputLatency;
+        let takeNumber = 0;
         const { tempoMap, env: { audioContext: { sampleRate } } } = project;
         const { loopArea } = timelineBox;
         const createFileBox = () => {
@@ -36,6 +37,7 @@ export var RecordAudio;
             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());
@@ -48,7 +50,7 @@ export var RecordAudio;
                 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);
             });
@@ -57,15 +59,17 @@ export var RecordAudio;
             return { trackBox, regionBox, warpMarkerBox };
         };
         const finalizeTake = (take, loopDurationPPQN) => {
-            const { regionBox, warpMarkerBox } = take;
+            const { trackBox, regionBox, warpMarkerBox } = take;
             if (regionBox.isAttached()) {
                 regionBox.duration.setValue(loopDurationPPQN);
                 regionBox.loopDuration.setValue(loopDurationPPQN);
-                regionBox.mute.setValue(true);
                 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));
@@ -112,7 +116,8 @@ export var RecordAudio;
                 editing.modify(() => {
                     if (regionBox.isAttached()) {
                         const { duration, loopDuration } = regionBox;
-                        const distanceInPPQN = Math.floor(currentPosition - regionBox.position.getValue());
+                        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);

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"}

package/dist/capture/RecordMidi.js

@@ -1,4 +1,4 @@
-import { Option, quantizeCeil, quantizeRound, Terminator, UUID } from "@opendaw/lib-std";
+import { Option, quantizeCeil, quantizeFloor, Terminator, UUID } from "@opendaw/lib-std";
 import { PPQN } from "@opendaw/lib-dsp";
 import { NoteEventBox, NoteEventCollectionBox, NoteRegionBox } from "@opendaw/studio-boxes";
 import { ColorCodes, NoteSignal, TrackType } from "@opendaw/studio-adapters";
@@ -8,81 +8,116 @@ export var RecordMidi;
     const MIN_NOTE_DURATION = PPQN.fromSignature(1, 128);
     RecordMidi.start = ({ notifier, project, capture }) => {
         const beats = PPQN.fromSignature(1, project.timelineBox.signature.denominator.getValue());
-        const { editing, boxGraph, engine, env: { audioContext }, timelineBox: { bpm } } = project;
+        const { editing, boxGraph, engine, env: { audioContext }, timelineBox } = project;
         const { position, isRecording } = engine;
-        const trackBox = RecordTrack.findOrCreate(editing, capture.audioUnitBox, TrackType.Notes);
+        const { loopArea } = timelineBox;
         const terminator = new Terminator();
         const activeNotes = new Map();
-        const latency = PPQN.secondsToPulses(audioContext.outputLatency ?? 10.0, bpm.getValue());
-        let writing = Option.None;
-        const createRegion = () => {
-            const writePosition = position.getValue() + latency;
-            editing.modify(() => {
-                const collection = NoteEventCollectionBox.create(boxGraph, UUID.generate());
-                const regionBox = NoteRegionBox.create(boxGraph, UUID.generate(), box => {
-                    box.regions.refer(trackBox.regions);
-                    box.events.refer(collection.owners);
-                    box.position.setValue(Math.max(quantizeRound(writePosition, beats), 0));
-                    box.hue.setValue(ColorCodes.forTrackType(TrackType.Notes));
-                });
-                capture.addRecordedRegion(regionBox);
-                project.selection.select(regionBox);
-                engine.ignoreNoteRegion(regionBox.address.uuid);
-                writing = Option.wrap({ region: regionBox, collection });
-            }, false);
+        const latency = PPQN.secondsToPulses(audioContext.outputLatency ?? 10.0, timelineBox.bpm.getValue());
+        let currentTake = Option.None;
+        let lastPosition = 0;
+        let positionOffset = 0;
+        let takeNumber = 0;
+        const createTakeRegion = (position, forceNewTrack) => {
+            takeNumber++;
+            const trackBox = RecordTrack.findOrCreate(editing, capture.audioUnitBox, TrackType.Notes, forceNewTrack);
+            const collection = NoteEventCollectionBox.create(boxGraph, UUID.generate());
+            const regionBox = NoteRegionBox.create(boxGraph, UUID.generate(), box => {
+                box.regions.refer(trackBox.regions);
+                box.events.refer(collection.owners);
+                box.position.setValue(position);
+                box.hue.setValue(ColorCodes.forTrackType(TrackType.Notes));
+                box.label.setValue(`Take ${takeNumber}`);
+            });
+            capture.addRecordedRegion(regionBox);
+            project.selection.select(regionBox);
+            engine.ignoreNoteRegion(regionBox.address.uuid);
+            return { trackBox, regionBox, collection };
+        };
+        const finalizeTake = (take, loopDurationPPQN) => {
+            const { trackBox, regionBox } = take;
+            if (regionBox.isAttached()) {
+                regionBox.duration.setValue(loopDurationPPQN);
+                regionBox.loopDuration.setValue(loopDurationPPQN);
+            }
+            if (trackBox.isAttached()) {
+                trackBox.enabled.setValue(false);
+            }
+        };
+        const startNewTake = (position) => {
+            currentTake = Option.wrap(createTakeRegion(position, true));
         };
         terminator.own(position.catchupAndSubscribe(owner => {
-            if (writing.isEmpty()) {
-                if (isRecording.getValue()) {
-                    createRegion();
-                }
-                else {
-                    return;
-                }
+            if (!isRecording.getValue()) {
+                return;
             }
-            const writePosition = owner.getValue() + latency;
-            const { region, collection } = writing.unwrap();
-            editing.modify(() => {
-                if (region.isAttached() && collection.isAttached()) {
-                    const { position, duration, loopDuration } = region;
-                    const newDuration = quantizeCeil(writePosition, beats) - position.getValue();
-                    duration.setValue(newDuration);
-                    loopDuration.setValue(newDuration);
-                    for (const event of activeNotes.values()) {
-                        if (event.isAttached()) {
-                            event.duration.setValue(Math.max(MIN_NOTE_DURATION, writePosition - region.position.getValue() - event.position.getValue()));
-                        }
-                        else {
-                            activeNotes.delete(event.pitch.getValue());
+            const currentPosition = owner.getValue();
+            const writePosition = currentPosition + latency;
+            const loopEnabled = loopArea.enabled.getValue();
+            const loopFrom = loopArea.from.getValue();
+            const loopTo = loopArea.to.getValue();
+            const loopDurationPPQN = loopTo - loopFrom;
+            if (loopEnabled && currentTake.nonEmpty() && currentPosition < lastPosition) {
+                positionOffset += loopDurationPPQN;
+                editing.modify(() => {
+                    currentTake.ifSome(take => finalizeTake(take, loopDurationPPQN));
+                    startNewTake(loopFrom);
+                }, false);
+            }
+            lastPosition = currentPosition;
+            if (currentTake.isEmpty()) {
+                editing.modify(() => {
+                    const pos = quantizeFloor(currentPosition, beats);
+                    currentTake = Option.wrap(createTakeRegion(pos, false));
+                }, false);
+            }
+            currentTake.ifSome(({ regionBox, collection }) => {
+                editing.modify(() => {
+                    if (regionBox.isAttached() && collection.isAttached()) {
+                        const { position: regionPosition, duration, loopDuration } = regionBox;
+                        const maxDuration = loopEnabled ? loopTo - regionPosition.getValue() : Infinity;
+                        const newDuration = Math.min(maxDuration, quantizeCeil(writePosition, beats) - regionPosition.getValue());
+                        duration.setValue(newDuration);
+                        loopDuration.setValue(newDuration);
+                        for (const { event, take, creationOffset } of activeNotes.values()) {
+                            if (event.isAttached()) {
+                                const elapsed = (positionOffset + writePosition) - (creationOffset + take.regionBox.position.getValue() + event.position.getValue());
+                                event.duration.setValue(Math.max(MIN_NOTE_DURATION, elapsed));
+                            }
+                            else {
+                                activeNotes.delete(event.pitch.getValue());
+                            }
                         }
                     }
-                }
-                else {
-                    terminator.terminate();
-                    writing = Option.None;
-                }
-            }, false);
+                    else {
+                        terminator.terminate();
+                        currentTake = Option.None;
+                    }
+                }, false);
+            });
         }));
         terminator.ownAll(notifier.subscribe((signal) => {
             const writePosition = position.getValue() + latency;
             if (NoteSignal.isOn(signal)) {
                 const { pitch, velocity } = signal;
-                if (writing.isEmpty()) {
-                    createRegion();
+                if (currentTake.isEmpty()) {
+                    return;
                 }
-                const { region, collection } = writing.unwrap();
+                const take = currentTake.unwrap();
+                const { regionBox, collection } = take;
                 editing.modify(() => {
-                    const position = writePosition - region.position.getValue();
-                    if (position < -PPQN.SemiQuaver) {
+                    const notePosition = writePosition - regionBox.position.getValue();
+                    if (notePosition < -PPQN.SemiQuaver) {
                         return;
                     }
-                    activeNotes.set(pitch, NoteEventBox.create(boxGraph, UUID.generate(), box => {
-                        box.position.setValue(Math.max(0, position));
+                    const event = NoteEventBox.create(boxGraph, UUID.generate(), box => {
+                        box.position.setValue(Math.max(0, notePosition));
                         box.duration.setValue(MIN_NOTE_DURATION);
                         box.pitch.setValue(pitch);
                         box.velocity.setValue(velocity);
                         box.events.refer(collection.events);
-                    }));
+                    });
+                    activeNotes.set(pitch, { event, take, creationOffset: positionOffset });
                 }, false);
             }
             else if (NoteSignal.isOff(signal)) {