@opendaw/studio-core 0.0.19 → 0.0.20

package/dist/dawproject/{DawProjectIO.js → DawProject.js}

@@ -1,10 +1,11 @@
 import JSZip from "jszip";
 import { Xml } from "@opendaw/lib-xml";
 import { asDefined, panic, UUID } from "@opendaw/lib-std";
-import { MetaDataSchema, ProjectSchema } from "@opendaw/lib-dawproject";
-export var DawProjectIO;
-(function (DawProjectIO) {
-    DawProjectIO.decode = async (buffer) => {
+import { FileReferenceSchema, MetaDataSchema, ProjectSchema } from "@opendaw/lib-dawproject";
+import { DawProjectExporter } from "./DawProjectExporter";
+export var DawProject;
+(function (DawProject) {
+    DawProject.decode = async (buffer) => {
         const zip = await JSZip.loadAsync(buffer);
         const metaData = Xml.parse(asDefined(await zip.file("metadata.xml")
             ?.async("string"), "No metadata.xml found"), MetaDataSchema);
@@ -28,4 +29,21 @@ export var DawProjectIO;
             }
         };
     };
-})(DawProjectIO || (DawProjectIO = {}));
+    DawProject.encode = (project, metaData) => {
+        const zip = new JSZip();
+        const projectSchema = DawProjectExporter.write(project, {
+            write: (path, buffer) => {
+                zip.file(path, buffer);
+                return Xml.element({ path, external: false }, FileReferenceSchema);
+            }
+        });
+        const metaDataXml = Xml.pretty(Xml.toElement("MetaData", metaData));
+        const projectXml = Xml.pretty(Xml.toElement("Project", projectSchema));
+        console.debug("encode");
+        console.debug(metaDataXml);
+        console.debug(projectXml);
+        zip.file("metadata.xml", metaDataXml);
+        zip.file("project.xml", projectXml);
+        return zip.generateAsync({ type: "arraybuffer" });
+    };
+})(DawProject || (DawProject = {}));

package/dist/dawproject/DawProjectExporter.d.ts

@@ -1,8 +1,9 @@
-import { ProjectDecoder } from "@opendaw/studio-adapters";
-export declare class DawProjectExporter {
-    #private;
-    static exportProject(skeleton: ProjectDecoder.Skeleton): DawProjectExporter;
-    constructor(skeleton: ProjectDecoder.Skeleton);
-    toProjectXml(): string;
+import { FileReferenceSchema, ProjectSchema } from "@opendaw/lib-dawproject";
+import { Project } from "../Project";
+export declare namespace DawProjectExporter {
+    interface ResourcePacker {
+        write(path: string, buffer: ArrayBufferLike): FileReferenceSchema;
+    }
+    const write: (project: Project, resourcePacker: ResourcePacker) => ProjectSchema;
 }
 //# sourceMappingURL=DawProjectExporter.d.ts.map

package/dist/dawproject/DawProjectExporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DawProjectExporter.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProjectExporter.ts"],"names":[],"mappings":"AASA,OAAO,EAAC,cAAc,EAAC,MAAM,0BAA0B,CAAA;AAEvD,qBAAa,kBAAkB;;IAC3B,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,cAAc,CAAC,QAAQ,GAAG,kBAAkB;gBAM/D,QAAQ,EAAE,cAAc,CAAC,QAAQ;IAE7C,YAAY,IAAI,MAAM;CAoBzB"}
+{"version":3,"file":"DawProjectExporter.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProjectExporter.ts"],"names":[],"mappings":"AAGA,OAAO,EAaH,mBAAmB,EAKnB,aAAa,EAUhB,MAAM,yBAAyB,CAAA;AAchC,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAQlC,yBAAiB,kBAAkB,CAAC;IAChC,UAAiB,cAAc;QAAE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,mBAAmB,CAAA;KAAC;IAE5F,MAAM,KAAK,GAAI,SAAS,OAAO,EAAE,gBAAgB,cAAc,kBA4PrE,CAAA;CACJ"}

package/dist/dawproject/DawProjectExporter.js

@@ -1,29 +1,252 @@
+import { asDefined, asInstanceOf, Color, ifDefined, isInstanceOf, Option, UUID } from "@opendaw/lib-std";
 import { Xml } from "@opendaw/lib-xml";
-import { ApplicationSchema, ArrangementSchema, ProjectSchema, RealParameterSchema, TransportSchema, Unit } from "@opendaw/lib-dawproject";
-export class DawProjectExporter {
-    static exportProject(skeleton) {
-        return new DawProjectExporter(skeleton);
-    }
-    #skeleton;
-    constructor(skeleton) { this.#skeleton = skeleton; }
-    toProjectXml() {
-        const { rootBox, timelineBox } = this.#skeleton.mandatoryBoxes;
-        const element = Xml.toElement("Project", Xml.element({
+import { dbToGain, PPQN } from "@opendaw/lib-dsp";
+import { ApplicationSchema, ArrangementSchema, AudioAlgorithm, AudioSchema, BuiltinDeviceSchema, ChannelRole, ChannelSchema, ClipSchema, ClipsSchema, DeviceRole, FileReferenceSchema, LanesSchema, NoteSchema, NotesSchema, ParameterEncoder, ProjectSchema, RealParameterSchema, TimeSignatureParameterSchema, TimeUnit, TrackSchema, TransportSchema, Unit, WarpSchema, WarpsSchema } from "@opendaw/lib-dawproject";
+import { AddressIdEncoder, BooleanField } from "@opendaw/lib-box";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { AudioFileBox, AudioUnitBox, NoteEventBox, NoteEventCollectionBox, TrackBox } from "@opendaw/studio-boxes";
+import { AudioUnitExportLayout } from "./AudioUnitExportLayout";
+import { ColorCodes } from "../ColorCodes";
+import { Html } from "@opendaw/lib-dom";
+import { encodeWavFloat } from "../Wav";
+import { DeviceBoxUtils } from "@opendaw/studio-adapters";
+import { DeviceIO } from "./DeviceIO";
+export var DawProjectExporter;
+(function (DawProjectExporter) {
+    DawProjectExporter.write = (project, resourcePacker) => {
+        const ids = new AddressIdEncoder();
+        const { boxGraph, timelineBox, rootBox, sampleManager } = project;
+        const audioUnits = rootBox.audioUnits.pointerHub.incoming()
+            .map(({ box }) => asInstanceOf(box, AudioUnitBox))
+            .sort((a, b) => a.index.getValue() - b.index.getValue());
+        boxGraph.boxes().forEach(box => box.accept({
+            visitAudioFileBox: (box) => sampleManager.getOrCreate(box.address.uuid).data
+                .ifSome(({ frames, numberOfFrames, sampleRate, numberOfChannels }) => resourcePacker.write(`samples/${box.fileName.getValue()}.wav`, encodeWavFloat({
+                channels: frames,
+                duration: numberOfFrames * sampleRate,
+                numberOfChannels,
+                sampleRate,
+                numFrames: numberOfFrames
+            })))
+        }));
+        const writeTransport = () => Xml.element({
+            tempo: Xml.element({
+                id: ids.getOrCreate(timelineBox.bpm.address),
+                value: timelineBox.bpm.getValue(),
+                unit: Unit.BPM
+            }, RealParameterSchema),
+            timeSignature: Xml.element({
+                numerator: timelineBox.signature.nominator.getValue(),
+                denominator: timelineBox.signature.denominator.getValue()
+            }, TimeSignatureParameterSchema)
+        }, TransportSchema);
+        const writeDevices = (field, deviceRole) => field.pointerHub
+            .incoming().map(({ box }) => {
+            const enabled = ("enabled" in box && isInstanceOf(box.enabled, BooleanField)
+                ? Option.wrap(box.enabled)
+                : Option.None)
+                .mapOr(field => ParameterEncoder.bool(ids.getOrCreate(field.address), field.getValue(), "On/Off"), undefined);
+            const deviceID = box.name;
+            const deviceName = DeviceBoxUtils.lookupLabelField(box).getValue();
+            const deviceVendor = "openDAW";
+            const id = ids.getOrCreate(box.address);
+            return Xml.element({
+                id,
+                deviceID,
+                deviceRole,
+                deviceName,
+                deviceVendor,
+                enabled,
+                loaded: true,
+                automatedParameters: [],
+                state: resourcePacker
+                    .write(`presets/${UUID.toString(box.address.uuid)}`, DeviceIO.exportDevice(box))
+            }, BuiltinDeviceSchema);
+        });
+        const colorForAudioType = (unitType) => {
+            const cssColor = ColorCodes.forAudioType(unitType);
+            if (cssColor === "") {
+                return "red";
+            }
+            const [r, g, b] = Html.readCssVarColor(ColorCodes.forAudioType(unitType))[0];
+            const RR = Math.round(r * 255).toString(16).padStart(2, "0");
+            const GG = Math.round(g * 255).toString(16).padStart(2, "0");
+            const BB = Math.round(b * 255).toString(16).padStart(2, "0");
+            return `#${RR}${GG}${BB}`;
+        };
+        const writeStructure = () => {
+            const tracks = AudioUnitExportLayout.layout(audioUnits);
+            const writeAudioUnitBox = (audioUnitBox, tracks) => {
+                const unitType = audioUnitBox.type.getValue();
+                const color = colorForAudioType(unitType);
+                const isPrimary = unitType === AudioUnitType.Output;
+                const isAux = unitType === AudioUnitType.Aux;
+                const inputBox = audioUnitBox.input.pointerHub.incoming().at(0)?.box;
+                const contentType = isPrimary ? "audio notes" // we copied that value from bitwig
+                    : isAux ? "audio" : (() => 
+                    // TODO Another location to remember to put devices in...?
+                    //  We could also read the first track type?
+                    inputBox?.accept({
+                        visitTapeDeviceBox: () => "audio",
+                        visitVaporisateurDeviceBox: () => "notes",
+                        visitNanoDeviceBox: () => "notes",
+                        visitPlayfieldDeviceBox: () => "notes",
+                        visitAudioBusBox: () => "tracks"
+                    }))() ?? undefined;
+                return Xml.element({
+                    id: ids.getOrCreate(audioUnitBox.address),
+                    name: DeviceBoxUtils.lookupLabelField(inputBox).getValue(),
+                    loaded: true,
+                    color,
+                    contentType,
+                    channel: Xml.element({
+                        id: ifDefined(inputBox, ({ address }) => ids.getOrCreate(address)),
+                        destination: isPrimary
+                            ? undefined
+                            : audioUnitBox.output.targetVertex
+                                .mapOr(({ box }) => ids.getOrCreate(box.address), undefined),
+                        role: (() => {
+                            switch (unitType) {
+                                case AudioUnitType.Instrument:
+                                    return ChannelRole.REGULAR;
+                                case AudioUnitType.Aux:
+                                    return ChannelRole.EFFECT;
+                                case AudioUnitType.Bus:
+                                case AudioUnitType.Output:
+                                    return ChannelRole.MASTER;
+                            }
+                        })(),
+                        devices: [
+                            ...(writeDevices(audioUnitBox.midiEffects, DeviceRole.NOTE_FX)),
+                            ...(writeDevices(audioUnitBox.input, DeviceRole.INSTRUMENT)),
+                            ...(writeDevices(audioUnitBox.audioEffects, DeviceRole.AUDIO_FX))
+                        ],
+                        volume: ParameterEncoder.linear(ids.getOrCreate(audioUnitBox.volume.address), dbToGain(audioUnitBox.volume.getValue()), 0.0, 2.0, "Volume"),
+                        pan: ParameterEncoder.normalized(ids.getOrCreate(audioUnitBox.panning.address), (audioUnitBox.panning.getValue() + 1.0) / 2.0, 0.0, 1.0, "Pan")
+                    }, ChannelSchema),
+                    tracks
+                }, TrackSchema);
+            };
+            const writeTracks = (tracks) => tracks.map((track) => writeAudioUnitBox(track.audioUnit, writeTracks(track.children)));
+            return writeTracks(tracks);
+        };
+        const writeAudioRegion = (region) => {
+            const audioFileBox = asInstanceOf(region.file.targetVertex.unwrap("No file at region").box, AudioFileBox);
+            const audioElement = sampleManager.getOrCreate(audioFileBox.address.uuid).data
+                .map(({ numberOfFrames, sampleRate, numberOfChannels }) => Xml.element({
+                duration: numberOfFrames / sampleRate,
+                channels: numberOfChannels,
+                sampleRate,
+                algorithm: AudioAlgorithm.REPITCH,
+                file: Xml.element({
+                    path: `samples/${audioFileBox.fileName.getValue()}.wav`,
+                    external: false
+                }, FileReferenceSchema)
+            }, AudioSchema));
+            const duration = region.duration.getValue() / PPQN.Quarter;
+            return Xml.element({
+                clips: [Xml.element({
+                        time: region.position.getValue() / PPQN.Quarter,
+                        duration,
+                        contentTimeUnit: TimeUnit.BEATS,
+                        playStart: 0.0,
+                        loopStart: 0.0,
+                        loopEnd: region.loopDuration.getValue() / PPQN.Quarter,
+                        enable: !region.mute.getValue(),
+                        name: region.label.getValue(),
+                        color: Color.hslToHex(region.hue.getValue(), 1.0, 0.60),
+                        content: [Xml.element({
+                                content: audioElement.mapOr(element => [element], []),
+                                contentTimeUnit: "beats",
+                                warps: [
+                                    Xml.element({
+                                        time: 0.0,
+                                        contentTime: 0.0
+                                    }, WarpSchema),
+                                    Xml.element({
+                                        time: duration,
+                                        contentTime: audioElement.mapOr(element => element.duration, 0)
+                                    }, WarpSchema)
+                                ]
+                            }, WarpsSchema)]
+                    }, ClipSchema)]
+            }, ClipsSchema);
+        };
+        const writeNoteRegion = (region) => {
+            const collectionBox = asInstanceOf(region.events.targetVertex
+                .unwrap("No notes in region").box, NoteEventCollectionBox);
+            return Xml.element({
+                clips: [Xml.element({
+                        time: region.position.getValue() / PPQN.Quarter,
+                        duration: region.duration.getValue() / PPQN.Quarter,
+                        contentTimeUnit: TimeUnit.BEATS,
+                        playStart: 0.0,
+                        loopStart: 0.0,
+                        loopEnd: region.loopDuration.getValue() / PPQN.Quarter,
+                        enable: !region.mute.getValue(),
+                        name: region.label.getValue(),
+                        color: Color.hslToHex(region.hue.getValue(), 1.0, 0.60),
+                        content: [Xml.element({
+                                notes: collectionBox.events.pointerHub.incoming()
+                                    .map(({ box }) => asInstanceOf(box, NoteEventBox))
+                                    .map(box => Xml.element({
+                                    time: box.position.getValue() / PPQN.Quarter,
+                                    duration: box.duration.getValue() / PPQN.Quarter,
+                                    key: box.pitch.getValue(),
+                                    channel: 0,
+                                    vel: box.velocity.getValue(),
+                                    rel: box.velocity.getValue()
+                                }, NoteSchema))
+                            }, NotesSchema)]
+                    }, ClipSchema)]
+            }, ClipsSchema);
+        };
+        // TODO Implement!
+        const writeValueRegion = (region) => Xml.element({
+            clips: [Xml.element({
+                    time: region.position.getValue() / PPQN.Quarter,
+                    duration: region.duration.getValue() / PPQN.Quarter,
+                    contentTimeUnit: TimeUnit.BEATS,
+                    playStart: 0.0,
+                    loopStart: 0.0,
+                    loopEnd: region.loopDuration.getValue() / PPQN.Quarter,
+                    enable: !region.mute.getValue(),
+                    name: region.label.getValue(),
+                    color: Color.hslToHex(region.hue.getValue(), 1.0, 0.60),
+                    content: []
+                }, ClipSchema)]
+        }, ClipsSchema);
+        const writeLanes = () => {
+            return audioUnits
+                .flatMap(audioUnitBox => audioUnitBox.tracks.pointerHub.incoming()
+                .map(({ box }) => asInstanceOf(box, TrackBox))
+                .sort((a, b) => a.index.getValue() - b.index.getValue())
+                .map(trackBox => Xml.element({
+                id: ids.getOrCreate(trackBox.address),
+                track: ids.getOrCreate(audioUnitBox.address),
+                lanes: trackBox.regions.pointerHub.incoming()
+                    .map(({ box }) => asDefined(box.accept({
+                    visitAudioRegionBox: (region) => writeAudioRegion(region),
+                    visitNoteRegionBox: (region) => writeNoteRegion(region),
+                    visitValueRegionBox: (region) => writeValueRegion(region)
+                }), "Could not write region."))
+            }, LanesSchema)));
+        };
+        return Xml.element({
             version: "1.0",
             application: Xml.element({
                 name: "openDAW",
                 version: "0.1"
             }, ApplicationSchema),
-            transport: Xml.element({
-                tempo: Xml.element({
-                    value: timelineBox.bpm.getValue(),
-                    unit: Unit.BPM
-                }, RealParameterSchema)
-            }, TransportSchema),
-            structure: [],
-            arrangement: Xml.element({}, ArrangementSchema),
+            transport: writeTransport(),
+            structure: writeStructure(),
+            arrangement: Xml.element({
+                lanes: Xml.element({
+                    lanes: writeLanes(),
+                    timeUnit: TimeUnit.BEATS
+                }, LanesSchema)
+            }, ArrangementSchema),
             scenes: []
-        }, ProjectSchema));
-        return Xml.pretty(element);
-    }
-}
+        }, ProjectSchema);
+    };
+})(DawProjectExporter || (DawProjectExporter = {}));

package/dist/dawproject/DawProjectExporter.test.js

@@ -2,15 +2,48 @@ import { describe, it } from "vitest";
 import { fileURLToPath } from "url";
 import * as path from "node:path";
 import * as fs from "node:fs";
-import { ProjectDecoder } from "@opendaw/studio-adapters";
-import { ProjectMigration } from "../ProjectMigration";
+import { Project } from "../Project";
+import { Option, panic, Terminable } from "@opendaw/lib-std";
+import { Xml } from "@opendaw/lib-xml";
+import { FileReferenceSchema } from "@opendaw/lib-dawproject";
 import { DawProjectExporter } from "./DawProjectExporter";
 describe("DawProjectExport", () => {
     it("export", async () => {
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
-        const buffer = fs.readFileSync(path.join(__dirname, "../../../../../packages/app/studio/public/templates/Fatso.od"));
-        const skeleton = ProjectDecoder.decode(buffer.buffer);
-        ProjectMigration.migrate(skeleton);
-        console.debug(DawProjectExporter.exportProject(skeleton).toProjectXml());
+        const projectPath = "../../../../../test-files/all-devices.od";
+        const buffer = fs.readFileSync(path.join(__dirname, projectPath));
+        const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        const project = Project.load({
+            sampleRate: 44100,
+            sampleManager: new class {
+                record(loader) {
+                    throw new Error("Method not implemented.");
+                }
+                getOrCreate(format) {
+                    return new class {
+                        data = Option.None;
+                        peaks = Option.None;
+                        uuid = format;
+                        state = { type: "progress", progress: 0.0 };
+                        meta = Option.None;
+                        invalidate() { throw new Error("Method not implemented."); }
+                        subscribe(_observer) {
+                            return Terminable.Empty;
+                        }
+                    };
+                }
+                invalidate(_uuid) {
+                    return panic("Method not implemented.");
+                }
+            }
+        }, arrayBuffer);
+        const schema = DawProjectExporter.write(project, {
+            write: (path, buffer) => {
+                console.debug(`store ${buffer.byteLength} bytes at ${path}`);
+                return Xml.element({ path, external: false }, FileReferenceSchema);
+            }
+        });
+        // console.dir(schema, {depth: Number.MAX_SAFE_INTEGER})
+        console.debug(Xml.pretty(Xml.toElement("Project", schema)));
     });
 });

package/dist/dawproject/DawProjectImport.d.ts

@@ -0,0 +1,12 @@
+import { UUID } from "@opendaw/lib-std";
+import { ProjectSchema } from "@opendaw/lib-dawproject";
+import { ProjectDecoder } from "@opendaw/studio-adapters";
+import { DawProject } from "./DawProject";
+export declare namespace DawProjectImport {
+    type Result = {
+        audioIds: ReadonlyArray<UUID.Format>;
+        skeleton: ProjectDecoder.Skeleton;
+    };
+    const read: (schema: ProjectSchema, resources: DawProject.ResourceProvider) => Promise<Result>;
+}
+//# sourceMappingURL=DawProjectImport.d.ts.map

package/dist/dawproject/DawProjectImport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DawProjectImport.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProjectImport.ts"],"names":[],"mappings":"AAAA,OAAO,EAgBH,IAAI,EAEP,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAcH,aAAa,EAOhB,MAAM,yBAAyB,CAAA;AAuBhC,OAAO,EAAyC,cAAc,EAAY,MAAM,0BAA0B,CAAA;AAC1G,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAA;AAQvC,yBAAiB,gBAAgB,CAAC;IAW9B,KAAY,MAAM,GAAG;QACjB,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrC,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAA;KACpC,CAAA;IAOM,MAAM,IAAI,GAAU,QAAQ,aAAa,EAAE,WAAW,UAAU,CAAC,gBAAgB,KAAG,OAAO,CAAC,MAAM,CA6WxG,CAAA;CAaJ"}