@opendaw/studio-core 0.0.6

package/dist/Project.js

@@ -0,0 +1,173 @@
+import { asInstanceOf, ByteArrayOutput, Option, panic, Terminator, UUID } from "@opendaw/lib-std";
+import { BoxGraph, Editing } from "@opendaw/lib-box";
+import { AudioBusBox, AudioUnitBox, BoxIO, GrooveShuffleBox, RootBox, TimelineBox, UserInterfaceBox, ValueEventCurveBox } from "@opendaw/studio-boxes";
+import { BoxAdapters, IconSymbol, ParameterFieldAdapters, ProjectDecoder, RootBoxAdapter, TimelineBoxAdapter, UserEditingManager, VertexSelection } from "@opendaw/studio-adapters";
+import { LiveStreamReceiver } from "@opendaw/lib-fusion";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { Mixer } from "./Mixer";
+// Main Entry Point for a Project
+//
+export class Project {
+    static new(env) {
+        const boxGraph = new BoxGraph(Option.wrap(BoxIO.create));
+        const isoString = new Date().toISOString();
+        console.debug(`New Project created on ${isoString}`);
+        boxGraph.beginTransaction();
+        const grooveShuffleBox = GrooveShuffleBox.create(boxGraph, UUID.generate(), box => {
+            box.label.setValue("Groove Shuffle");
+        });
+        const rootBox = RootBox.create(boxGraph, UUID.generate(), box => {
+            box.groove.refer(grooveShuffleBox);
+            box.created.setValue(isoString);
+        });
+        const userInterfaceBox = UserInterfaceBox.create(boxGraph, UUID.generate());
+        const masterBusBox = AudioBusBox.create(boxGraph, UUID.generate(), box => {
+            box.collection.refer(rootBox.audioBusses);
+            box.label.setValue("Output");
+            box.icon.setValue(IconSymbol.toName(IconSymbol.SpeakerHeadphone));
+            box.color.setValue(/*Colors.blue*/ "hsl(189, 100%, 65%)"); // TODO
+        });
+        const masterAudioUnit = AudioUnitBox.create(boxGraph, UUID.generate(), box => {
+            box.type.setValue(AudioUnitType.Output);
+            box.collection.refer(rootBox.audioUnits);
+            box.output.refer(rootBox.outputDevice);
+            box.index.setValue(0);
+        });
+        const timelineBox = TimelineBox.create(boxGraph, UUID.generate());
+        rootBox.timeline.refer(timelineBox.root);
+        userInterfaceBox.root.refer(rootBox.users);
+        masterBusBox.output.refer(masterAudioUnit.input);
+        boxGraph.endTransaction();
+        return new Project(env, boxGraph, {
+            rootBox,
+            userInterfaceBox,
+            masterBusBox,
+            masterAudioUnit,
+            timelineBox
+        });
+    }
+    static load(env, arrayBuffer) {
+        const skeleton = ProjectDecoder.decode(arrayBuffer);
+        this.#migrate(skeleton);
+        return new Project(env, skeleton.boxGraph, skeleton.mandatoryBoxes);
+    }
+    static #migrate({ boxGraph, mandatoryBoxes }) {
+        const { rootBox } = mandatoryBoxes;
+        if (rootBox.groove.targetAddress.isEmpty()) {
+            console.debug("Migrate to global GrooveShuffleBox");
+            boxGraph.beginTransaction();
+            rootBox.groove.refer(GrooveShuffleBox.create(boxGraph, UUID.generate()));
+            boxGraph.endTransaction();
+        }
+        const globalShuffle = asInstanceOf(rootBox.groove.targetVertex.unwrap(), GrooveShuffleBox).label;
+        if (globalShuffle.getValue() !== "Groove Shuffle") {
+            boxGraph.beginTransaction();
+            globalShuffle.setValue("Groove Shuffle");
+            boxGraph.endTransaction();
+        }
+        // TODO We can remove this when we delete all not-migrated, local(!) project files from my machine
+        boxGraph.boxes().forEach(box => box.accept({
+            visitZeitgeistDeviceBox: (box) => {
+                if (box.groove.targetAddress.isEmpty()) {
+                    console.debug("Migrate 'ZeitgeistDeviceBox' to GrooveShuffleBox");
+                    boxGraph.beginTransaction();
+                    box.groove.refer(rootBox.groove.targetVertex.unwrap());
+                    boxGraph.endTransaction();
+                }
+            },
+            visitValueEventBox: (eventBox) => {
+                const slope = eventBox.slope.getValue();
+                if (isNaN(slope)) {
+                    return;
+                } // already migrated, nothing to do
+                if (slope === 0.0) { // never set
+                    console.debug("Migrate 'ValueEventBox'");
+                    boxGraph.beginTransaction();
+                    eventBox.slope.setValue(NaN);
+                    boxGraph.endTransaction();
+                }
+                else if (eventBox.interpolation.getValue() === 1) { // linear
+                    if (slope === 0.5) {
+                        console.debug("Migrate 'ValueEventBox' to linear");
+                        boxGraph.beginTransaction();
+                        eventBox.slope.setValue(NaN);
+                        boxGraph.endTransaction();
+                    }
+                    else {
+                        console.debug("Migrate 'ValueEventBox' to new ValueEventCurveBox");
+                        boxGraph.beginTransaction();
+                        ValueEventCurveBox.create(boxGraph, UUID.generate(), box => {
+                            box.event.refer(eventBox.interpolation);
+                            box.slope.setValue(slope);
+                        });
+                        eventBox.slope.setValue(NaN);
+                        boxGraph.endTransaction();
+                    }
+                }
+            }
+        }));
+    }
+    #terminator = new Terminator();
+    #env;
+    boxGraph;
+    rootBox;
+    userInterfaceBox;
+    masterBusBox;
+    masterAudioUnit;
+    timelineBox;
+    editing;
+    selection;
+    boxAdapters;
+    userEditingManager;
+    parameterFieldAdapters;
+    liveStreamReceiver;
+    mixer;
+    constructor(env, boxGraph, { rootBox, userInterfaceBox, masterBusBox, masterAudioUnit, timelineBox }) {
+        this.#env = env;
+        this.boxGraph = boxGraph;
+        this.rootBox = rootBox;
+        this.userInterfaceBox = userInterfaceBox;
+        this.masterBusBox = masterBusBox;
+        this.masterAudioUnit = masterAudioUnit;
+        this.timelineBox = timelineBox;
+        this.liveStreamReceiver = this.#terminator.own(new LiveStreamReceiver());
+        this.editing = new Editing(this.boxGraph);
+        this.selection = new VertexSelection(this.editing, this.boxGraph);
+        this.parameterFieldAdapters = new ParameterFieldAdapters();
+        this.boxAdapters = this.#terminator.own(new BoxAdapters(this));
+        this.userEditingManager = new UserEditingManager(this.editing);
+        this.userEditingManager.follow(this.userInterfaceBox);
+        this.selection.switch(this.userInterfaceBox.selection);
+        this.mixer = new Mixer(this.rootBoxAdapter.audioUnits);
+        console.debug(`Project was created on ${this.rootBoxAdapter.created.toString()}`);
+    }
+    own(terminable) { return this.#terminator.own(terminable); }
+    ownAll(...terminables) { return this.#terminator.ownAll(...terminables); }
+    spawn() { return this.#terminator.spawn(); }
+    get bpm() { return this.timelineBox.bpm.getValue(); }
+    get rootBoxAdapter() { return this.boxAdapters.adapterFor(this.rootBox, RootBoxAdapter); }
+    get timelineBoxAdapter() { return this.boxAdapters.adapterFor(this.timelineBox, TimelineBoxAdapter); }
+    get audioManager() { return this.#env.audioManager; }
+    get clipSequencing() { return panic("Only available in audio context"); }
+    get isAudioContext() { return false; }
+    get isMainThread() { return true; }
+    get liveStreamBroadcaster() { return panic("Only available in audio context"); }
+    toArrayBuffer() {
+        const output = ByteArrayOutput.create();
+        output.writeInt(ProjectDecoder.MAGIC_HEADER_OPEN);
+        output.writeInt(ProjectDecoder.FORMAT_VERSION);
+        // store all boxes
+        const boxGraphChunk = this.boxGraph.toArrayBuffer();
+        output.writeInt(boxGraphChunk.byteLength);
+        output.writeBytes(new Int8Array(boxGraphChunk));
+        // store mandatory boxes' addresses
+        UUID.toDataOutput(output, this.rootBox.address.uuid);
+        UUID.toDataOutput(output, this.userInterfaceBox.address.uuid);
+        UUID.toDataOutput(output, this.masterBusBox.address.uuid);
+        UUID.toDataOutput(output, this.masterAudioUnit.address.uuid);
+        UUID.toDataOutput(output, this.timelineBox.address.uuid);
+        return output.toArrayBuffer();
+    }
+    copy() { return Project.load(this.#env, this.toArrayBuffer()); }
+    terminate() { this.#terminator.terminate(); }
+}

package/dist/ProjectEnv.d.ts

@@ -0,0 +1,5 @@
+import { AudioLoaderManager } from "@opendaw/studio-adapters";
+export interface ProjectEnv {
+    audioManager: AudioLoaderManager;
+}
+//# sourceMappingURL=ProjectEnv.d.ts.map

package/dist/ProjectEnv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectEnv.d.ts","sourceRoot":"","sources":["../src/ProjectEnv.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAA;AAE3D,MAAM,WAAW,UAAU;IACvB,YAAY,EAAE,kBAAkB,CAAA;CACnC"}

package/dist/ProjectEnv.js

@@ -0,0 +1 @@
+export {};

package/dist/RecordingWorklet.d.ts

@@ -0,0 +1,9 @@
+import { int } from "@opendaw/lib-std";
+import { WorkletFactory } from "./WorkletFactory";
+export declare class RecordingWorklet extends AudioWorkletNode {
+    #private;
+    static bootFactory(context: BaseAudioContext, url: string): Promise<WorkletFactory<RecordingWorklet>>;
+    static create(factory: WorkletFactory<RecordingWorklet>, numChannels: int, numChunks?: int): RecordingWorklet;
+    private constructor();
+}
+//# sourceMappingURL=RecordingWorklet.d.ts.map

package/dist/RecordingWorklet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordingWorklet.d.ts","sourceRoot":"","sources":["../src/RecordingWorklet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,GAAG,EAAC,MAAM,kBAAkB,CAAA;AAG/C,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAK/C,qBAAa,gBAAiB,SAAQ,gBAAgB;;WACrC,WAAW,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC;IAI3G,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,cAAc,CAAC,gBAAgB,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE,SAAS,GAAE,GAAQ,GAAG,gBAAgB;IAUjH,OAAO;CAuBV"}

package/dist/RecordingWorklet.js

@@ -0,0 +1,42 @@
+import { EmptyExec } from "@opendaw/lib-std";
+import { Files } from "@opendaw/lib-dom";
+import { mergeChunkPlanes, RingBuffer } from "@opendaw/studio-adapters";
+import { WorkletFactory } from "./WorkletFactory";
+import { encodeWavFloat } from "./Wav";
+const RenderQuantum = 128;
+export class RecordingWorklet extends AudioWorkletNode {
+    static async bootFactory(context, url) {
+        return WorkletFactory.boot(context, url);
+    }
+    static create(factory, numChannels, numChunks = 64) {
+        const audioBytes = numChannels * numChunks * RenderQuantum * Float32Array.BYTES_PER_ELEMENT;
+        const pointerBytes = Int32Array.BYTES_PER_ELEMENT * 2;
+        const sab = new SharedArrayBuffer(audioBytes + pointerBytes);
+        const buffer = { sab, numChunks, numChannels, bufferSize: RenderQuantum };
+        return factory.create(context => new RecordingWorklet(context, buffer));
+    }
+    #reader;
+    constructor(context, config) {
+        super(context, "recording-processor", {
+            numberOfInputs: 1,
+            channelCount: config.numChannels,
+            channelCountMode: "explicit",
+            processorOptions: config
+        });
+        const sampleRate = this.context.sampleRate;
+        const output = [];
+        const seconds = 3.1452;
+        const numFrames = Math.ceil(sampleRate * seconds);
+        console.debug(`numFrames: ${numFrames}`);
+        this.#reader = RingBuffer.reader(config, array => {
+            output.push(array);
+            if (output.length * RenderQuantum >= numFrames) {
+                this.#reader.stop();
+                const channels = mergeChunkPlanes(output, numFrames);
+                const wav = encodeWavFloat({ channels, numFrames, sampleRate });
+                Files.save(wav, { suggestedName: "recording.wav" })
+                    .then(() => console.debug("WAV saved"), EmptyExec);
+            }
+        });
+    }
+}

package/dist/Wav.d.ts

@@ -0,0 +1,6 @@
+export declare const encodeWavFloat: (audio: {
+    channels: ReadonlyArray<Float32Array>;
+    sampleRate: number;
+    numFrames: number;
+} | AudioBuffer) => ArrayBuffer;
+//# sourceMappingURL=Wav.d.ts.map

package/dist/Wav.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Wav.d.ts","sourceRoot":"","sources":["../src/Wav.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,GAAI,OAAO;IAClC,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAA;CACpB,GAAG,WAAW,KAAG,WA2CjB,CAAA"}

package/dist/Wav.js

@@ -0,0 +1,46 @@
+import { Arrays } from "@opendaw/lib-std";
+export const encodeWavFloat = (audio) => {
+    const MAGIC_RIFF = 0x46464952;
+    const MAGIC_WAVE = 0x45564157;
+    const MAGIC_FMT = 0x20746d66;
+    const MAGIC_DATA = 0x61746164;
+    const bytesPerChannel = Float32Array.BYTES_PER_ELEMENT;
+    const sampleRate = audio.sampleRate;
+    let numFrames;
+    let numberOfChannels;
+    let channels;
+    if (audio instanceof AudioBuffer) {
+        channels = Arrays.create(index => audio.getChannelData(index), audio.numberOfChannels);
+        numFrames = audio.length;
+        numberOfChannels = audio.numberOfChannels;
+    }
+    else {
+        channels = audio.channels;
+        numFrames = audio.numFrames;
+        numberOfChannels = audio.channels.length;
+    }
+    const size = 44 + numFrames * numberOfChannels * bytesPerChannel;
+    const buf = new ArrayBuffer(size);
+    const view = new DataView(buf);
+    view.setUint32(0, MAGIC_RIFF, true);
+    view.setUint32(4, size - 8, true);
+    view.setUint32(8, MAGIC_WAVE, true);
+    view.setUint32(12, MAGIC_FMT, true);
+    view.setUint32(16, 16, true); // chunk length
+    view.setUint16(20, 3, true); // compression
+    view.setUint16(22, numberOfChannels, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, sampleRate * numberOfChannels * bytesPerChannel, true);
+    view.setUint16(32, numberOfChannels * bytesPerChannel, true);
+    view.setUint16(34, 8 * bytesPerChannel, true);
+    view.setUint32(36, MAGIC_DATA, true);
+    view.setUint32(40, numberOfChannels * numFrames * bytesPerChannel, true);
+    let w = 44;
+    for (let i = 0; i < numFrames; ++i) {
+        for (let j = 0; j < numberOfChannels; ++j) {
+            view.setFloat32(w, channels[j][i], true);
+            w += bytesPerChannel;
+        }
+    }
+    return view.buffer;
+};

package/dist/WorkletFactory.d.ts

@@ -0,0 +1,8 @@
+import { Func } from "@opendaw/lib-std";
+export declare class WorkletFactory<W extends AudioWorkletNode> {
+    #private;
+    static boot<W extends AudioWorkletNode>(context: BaseAudioContext, moduleURL: string): Promise<WorkletFactory<W>>;
+    constructor(context: BaseAudioContext);
+    create(factory: Func<BaseAudioContext, W>): W;
+}
+//# sourceMappingURL=WorkletFactory.d.ts.map

package/dist/WorkletFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkletFactory.d.ts","sourceRoot":"","sources":["../src/WorkletFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAGrC,qBAAa,cAAc,CAAC,CAAC,SAAS,gBAAgB;;IAClD,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,gBAAgB,EAAE,OAAO,EAAE,gBAAgB,EACzB,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;gBAM1E,OAAO,EAAE,gBAAgB;IAErC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,GAAG,CAAC;CAChD"}

package/dist/WorkletFactory.js

@@ -0,0 +1,9 @@
+import { Promises } from "@opendaw/lib-runtime";
+export class WorkletFactory {
+    static boot(context, moduleURL) {
+        return Promises.retry(() => context.audioWorklet.addModule(moduleURL).then(() => new WorkletFactory(context)));
+    }
+    #context;
+    constructor(context) { this.#context = context; }
+    create(factory) { return factory(this.#context); }
+}

package/dist/Worklets.d.ts

@@ -0,0 +1,22 @@
+import { int } from "@opendaw/lib-std";
+import { ExportStemsConfiguration } from "@opendaw/studio-adapters";
+import { WorkletFactory } from "./WorkletFactory";
+import { EngineWorklet } from "./EngineWorklet";
+import { MeterWorklet } from "./MeterWorklet";
+import { RecordingWorklet } from "./RecordingWorklet";
+import { Project } from "./Project";
+export type WorkletUrls = {
+    meter: string;
+    engine: string;
+    recording: string;
+};
+export declare class Worklets {
+    #private;
+    static install(context: AudioContext, { engine, meter, recording }: WorkletUrls): Promise<Worklets>;
+    static get(context: AudioContext): Worklets;
+    constructor(engine: WorkletFactory<EngineWorklet>, meter: WorkletFactory<MeterWorklet>, recording: WorkletFactory<RecordingWorklet>);
+    createMeter(numberOfChannels: int): MeterWorklet;
+    createEngine(project: Project, exportConfiguration?: ExportStemsConfiguration): EngineWorklet;
+    createRecording(numberOfChannels: int, numChunks: int): RecordingWorklet;
+}
+//# sourceMappingURL=Worklets.d.ts.map

package/dist/Worklets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Worklets.d.ts","sourceRoot":"","sources":["../src/Worklets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,GAAG,EAAC,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAC,wBAAwB,EAAC,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEjC,MAAM,MAAM,WAAW,GAAG;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,qBAAa,QAAQ;;WACJ,OAAO,CAAC,OAAO,EAAE,YAAY,EAAE,EAAC,MAAM,EAAE,KAAK,EAAE,SAAS,EAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAYvG,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,YAAY,GAAG,QAAQ;gBAQ/B,MAAM,EAAE,cAAc,CAAC,aAAa,CAAC,EACrC,KAAK,EAAE,cAAc,CAAC,YAAY,CAAC,EACnC,SAAS,EAAE,cAAc,CAAC,gBAAgB,CAAC;IAMvD,WAAW,CAAC,gBAAgB,EAAE,GAAG,GAAG,YAAY;IAIhD,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,mBAAmB,CAAC,EAAE,wBAAwB,GAAG,aAAa;IAI7F,eAAe,CAAC,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,GAAG,gBAAgB;CAG3E"}

package/dist/Worklets.js

@@ -0,0 +1,36 @@
+import { asDefined } from "@opendaw/lib-std";
+import { EngineWorklet } from "./EngineWorklet";
+import { MeterWorklet } from "./MeterWorklet";
+import { RecordingWorklet } from "./RecordingWorklet";
+export class Worklets {
+    static async install(context, { engine, meter, recording }) {
+        return Promise.all([
+            EngineWorklet.bootFactory(context, engine),
+            MeterWorklet.bootFactory(context, meter),
+            RecordingWorklet.bootFactory(context, recording)
+        ]).then(([engine, meter, recording]) => {
+            const worklets = new Worklets(engine, meter, recording);
+            this.#map.set(context, worklets);
+            return worklets;
+        });
+    }
+    static get(context) { return asDefined(this.#map.get(context), "Worklets not installed"); }
+    static #map = new WeakMap();
+    #meter;
+    #engine;
+    #recording;
+    constructor(engine, meter, recording) {
+        this.#meter = meter;
+        this.#engine = engine;
+        this.#recording = recording;
+    }
+    createMeter(numberOfChannels) {
+        return MeterWorklet.create(this.#meter, numberOfChannels);
+    }
+    createEngine(project, exportConfiguration) {
+        return this.#engine.create(context => new EngineWorklet(context, project, exportConfiguration));
+    }
+    createRecording(numberOfChannels, numChunks) {
+        return RecordingWorklet.create(this.#recording, numberOfChannels, numChunks);
+    }
+}