@effetune/dsp 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -16,12 +16,15 @@ export type {
   DelayOptions,
   TimeAlignmentOptions,
   AMRadioSimulatorOptions,
+  AutoFilterOptions,
   AutoLevelerOptions,
+  AutoPanOptions,
   BandPassFilterOptions,
   BitCrusherOptions,
   BluetoothSBCSimulatorOptions,
   BrickwallLimiterOptions,
   CassetteArtifactsOptions,
+  ChorusOptions,
   CombFilterOptions,
   CommonEffectOptions,
   CompressorOptions,
@@ -40,6 +43,7 @@ export type {
   ExpanderOptions,
   FDNReverbOptions,
   FMRadioSimulatorOptions,
+  FrequencyShifterOptions,
   FifteenBandGEQOptions,
   FifteenBandPEQOptions,
   FiveBandDynamicEQOptions,
@@ -70,8 +74,11 @@ export type {
   NarrowRangeOptions,
   NoiseBlenderOptions,
   OscillatorOptions,
+  PhaserOptions,
+  PhaseSelectEQOptions,
   PitchShifterOptions,
   PowerAmpSagOptions,
+  RotarySpeakerOptions,
   RSReverbOptions,
   RoomEQOptions,
   SaturationOptions,
@@ -107,12 +114,15 @@ export {
   Delay,
   TimeAlignment,
   AMRadioSimulator,
+  AutoFilter,
   AutoLeveler,
+  AutoPan,
   BandPassFilter,
   BitCrusher,
   BluetoothSBCSimulator,
   BrickwallLimiter,
   CassetteArtifacts,
+  Chorus,
   CombFilter,
   Compressor,
   CrossfeedFilter,
@@ -129,6 +139,7 @@ export {
   Expander,
   FDNReverb,
   FMRadioSimulator,
+  FrequencyShifter,
   FifteenBandGEQ,
   FifteenBandPEQ,
   FiveBandDynamicEQ,
@@ -158,8 +169,11 @@ export {
   NarrowRange,
   NoiseBlender,
   Oscillator,
+  Phaser,
+  PhaseSelectEQ,
   PitchShifter,
   PowerAmpSag,
+  RotarySpeaker,
   RSReverb,
   RoomEQ,
   Saturation,
@@ -193,12 +207,15 @@ export {
   createDelay,
   createTimeAlignment,
   createAMRadioSimulator,
+  createAutoFilter,
   createAutoLeveler,
+  createAutoPan,
   createBandPassFilter,
   createBitCrusher,
   createBluetoothSBCSimulator,
   createBrickwallLimiter,
   createCassetteArtifacts,
+  createChorus,
   createCombFilter,
   createCompressor,
   createCrossfeedFilter,
@@ -213,6 +230,7 @@ export {
   createExpander,
   createFDNReverb,
   createFMRadioSimulator,
+  createFrequencyShifter,
   createFifteenBandGEQ,
   createFifteenBandPEQ,
   createFiveBandDynamicEQ,
@@ -242,8 +260,11 @@ export {
   createNarrowRange,
   createNoiseBlender,
   createOscillator,
+  createPhaser,
+  createPhaseSelectEQ,
   createPitchShifter,
   createPowerAmpSag,
+  createRotarySpeaker,
   createRSReverb,
   createRoomEQ,
   createSaturation,
@@ -267,7 +288,12 @@ export type { EffectDefinition } from './effect.js';
 import type { Effect } from './effect.js';
 import type { EffectChannel, EffectType } from './generated-effects.js';
 
-export declare class EffeTuneError extends Error {}
+export declare class EffeTuneError extends Error {
+  readonly code?: string;
+  readonly path?: string;
+  readonly nodeId?: string;
+  readonly edgeId?: string;
+}
 export declare class ValidationError extends EffeTuneError {}
 export declare class EffectError extends EffeTuneError {}
 export declare class AssetError extends EffeTuneError {}
@@ -519,6 +545,226 @@ export declare function createChain(
   options?: CreateChainOptions
 ): Promise<Chain>;
 
+export interface GraphEndpoint {
+  readonly id: string;
+}
+
+export interface GraphNode extends ChainEffect {}
+
+export interface GraphNodeInput extends ChainEffectInput {
+  readonly id: string;
+}
+
+export interface GraphEdge {
+  readonly id: string;
+  readonly source: string;
+  readonly destination: string;
+  readonly gain: number;
+  readonly mute: boolean;
+  readonly pan?: number;
+  readonly mixGroup: string;
+  readonly solo: boolean;
+}
+
+export interface GraphEdgeInput {
+  readonly id: string;
+  readonly source: string;
+  readonly destination: string;
+  readonly gain?: number;
+  readonly mute?: boolean;
+  readonly pan?: number;
+  readonly mixGroup?: string;
+  readonly solo?: boolean;
+}
+
+export interface GraphDocument {
+  readonly version: 1;
+  readonly input: GraphEndpoint;
+  readonly output: GraphEndpoint;
+  readonly nodes: readonly GraphNode[];
+  readonly edges: readonly GraphEdge[];
+}
+
+export interface GraphDocumentInput {
+  readonly version: 1;
+  readonly input: GraphEndpoint;
+  readonly output: GraphEndpoint;
+  readonly nodes: readonly GraphNodeInput[];
+  readonly edges: readonly GraphEdgeInput[];
+}
+
+export interface GraphCompileSnapshot {
+  readonly version: 1;
+  readonly identity: boolean;
+  readonly silence: boolean;
+  readonly effectiveSchedule: readonly string[];
+  readonly nodes: readonly GraphCompileNodeSnapshot[];
+  readonly edges: readonly GraphCompileEdgeSnapshot[];
+  readonly outputLatency: readonly number[];
+  readonly outputCompensation: readonly number[];
+  readonly latencySamples: number;
+  readonly capacity: Readonly<{ bufferSlots: number; workspaceBytes: number }>;
+}
+
+export interface GraphCompileNodeSnapshot {
+  readonly id: string;
+  readonly effective: boolean;
+  readonly dormant: boolean;
+  readonly enabled: boolean;
+  readonly disabledBypass: boolean;
+  readonly scheduleIndex: number | null;
+  readonly bufferSlot: number | null;
+  readonly processingGroup: Readonly<{ firstChannel: number; channelCount: number }>;
+  readonly kernelLatency: number;
+  readonly inputLatency: readonly number[];
+  readonly outputLatency: readonly number[];
+  readonly preNodeCompensation: readonly number[];
+}
+
+export interface GraphCompileEdgeSnapshot {
+  readonly id: string;
+  readonly active: boolean;
+  readonly suppressed: boolean;
+  readonly dormant: boolean;
+  readonly fanInCompensation: readonly number[];
+}
+
+export type GraphVisualizationState =
+  | 'structural'
+  | 'effective'
+  | 'dormant'
+  | 'disabled-bypass'
+  | 'suppressed';
+
+export interface GraphVisualizationEndpoint {
+  readonly id: string;
+  readonly kind: 'input' | 'output';
+}
+
+export interface GraphVisualizationEffectNode {
+  readonly id: string;
+  readonly kind: 'effect';
+  readonly effectType: EffectType;
+  readonly enabled: boolean;
+  readonly effective?: boolean;
+  readonly dormant?: boolean;
+  readonly disabledBypass?: boolean;
+  readonly state: GraphVisualizationState;
+}
+
+export interface GraphVisualizationEdge {
+  readonly id: string;
+  readonly source: string;
+  readonly destination: string;
+  readonly active?: boolean;
+  readonly suppressed?: boolean;
+  readonly dormant?: boolean;
+  readonly state: GraphVisualizationState;
+}
+
+export interface GraphVisualizationSnapshot {
+  readonly version: 1;
+  readonly nodes: readonly (GraphVisualizationEndpoint | GraphVisualizationEffectNode)[];
+  readonly edges: readonly GraphVisualizationEdge[];
+}
+
+export interface GraphStructuralSnapshot {
+  readonly document: GraphDocument;
+  readonly topologicalOrder: readonly string[];
+  readonly incoming: Readonly<Record<string, readonly string[]>>;
+  readonly outgoing: Readonly<Record<string, readonly string[]>>;
+}
+
+export interface CreateGraphOptions extends ArtifactOptions {
+  readonly assetResolver?: AssetResolver | { resolve: AssetResolver };
+}
+
+export interface GraphProcessOptions {
+  readonly sampleRate: number;
+  readonly seed?: number;
+  readonly blockSize?: number;
+}
+
+export interface GraphStreamOptions extends GraphProcessOptions {
+  readonly channels?: number;
+}
+
+export interface GraphRecipeOptions {
+  readonly nodeId?: string;
+  readonly inputId?: string;
+  readonly outputId?: string;
+}
+
+export interface WetDryGraphOptions extends GraphRecipeOptions {
+  readonly wet?: number;
+  readonly dry?: number;
+}
+
+export interface SendReturnGraphOptions extends GraphRecipeOptions {
+  readonly send?: number;
+  readonly returnGain?: number;
+}
+
+export declare class Graph {
+  private constructor();
+  static load(input: string | GraphDocumentInput, options?: CreateGraphOptions): Promise<Graph>;
+  static fromChain(
+    chain: Chain | ChainDocumentInput | readonly (Effect | ChainEffectInput)[],
+    options?: CreateGraphOptions
+  ): Promise<Graph>;
+  static wetDry(effect: Effect | ChainEffectInput, options?: WetDryGraphOptions): GraphDocument;
+  static sendReturn(effect: Effect | ChainEffectInput, options?: SendReturnGraphOptions): GraphDocument;
+  readonly nodes: readonly GraphNode[];
+  readonly edges: readonly GraphEdge[];
+  toJSON(): GraphDocument;
+  toChain(): ChainDocument;
+  serialize(space?: number): string;
+  getNode(id: string): GraphNode | null;
+  getEdge(id: string): GraphEdge | null;
+  incoming(id: string): readonly GraphEdge[];
+  outgoing(id: string): readonly GraphEdge[];
+  structuralSnapshot(): GraphStructuralSnapshot;
+  visualizationSnapshot(): GraphVisualizationSnapshot;
+  stream(options: GraphStreamOptions): Promise<GraphStream>;
+  latencySamples(options: LatencyOptions): Promise<number>;
+  process(audio: readonly Float32Array[], options: GraphProcessOptions): Promise<Float32Array[]>;
+  close(): void;
+}
+
+export declare class GraphStream {
+  readonly graph: GraphDocument;
+  readonly latencySamples: number;
+  readonly compileSnapshot: GraphCompileSnapshot;
+  visualizationSnapshot(): GraphVisualizationSnapshot;
+  setParam(nodeId: string, parameterName: string, value: unknown): this;
+  reset(): this;
+  process(audio: readonly Float32Array[]): Promise<Float32Array[]>;
+  close(): void;
+}
+
+export declare function createGraph(
+  input: string | GraphDocumentInput,
+  options?: CreateGraphOptions
+): Promise<Graph>;
+
+export declare function normalizeGraphDocument(
+  input: string | GraphDocumentInput
+): GraphDocument;
+export declare function graphDocumentFromChain(
+  input: ChainDocumentInput | readonly (Effect | ChainEffectInput)[]
+): GraphDocument;
+export declare function chainDocumentFromGraph(
+  input: GraphDocumentInput
+): ChainDocument;
+export declare function createWetDryGraphDocument(
+  effect: Effect | ChainEffectInput,
+  options?: WetDryGraphOptions
+): GraphDocument;
+export declare function createSendReturnGraphDocument(
+  effect: Effect | ChainEffectInput,
+  options?: SendReturnGraphOptions
+): GraphDocument;
+
 export declare function parsePreset(
   input: string | ChainDocumentInput | readonly (Effect | ChainEffectInput)[]
 ): ChainDocument;

package/dist/index.js

@@ -25,12 +25,15 @@ export {
   Delay,
   TimeAlignment,
   AMRadioSimulator,
+  AutoFilter,
   AutoLeveler,
+  AutoPan,
   BitCrusher,
   BluetoothSBCSimulator,
   BrickwallLimiter,
   BandPassFilter,
   CassetteArtifacts,
+  Chorus,
   CombFilter,
   Compressor,
   CrossfeedFilter,
@@ -47,6 +50,7 @@ export {
   Expander,
   FDNReverb,
   FMRadioSimulator,
+  FrequencyShifter,
   FifteenBandGEQ,
   FifteenBandPEQ,
   FiveBandDynamicEQ,
@@ -76,8 +80,11 @@ export {
   NarrowRange,
   NoiseBlender,
   Oscillator,
+  Phaser,
+  PhaseSelectEQ,
   PitchShifter,
   PowerAmpSag,
+  RotarySpeaker,
   RSReverb,
   RoomEQ,
   Saturation,
@@ -111,12 +118,15 @@ export {
   createDelay,
   createTimeAlignment,
   createAMRadioSimulator,
+  createAutoFilter,
   createAutoLeveler,
+  createAutoPan,
   createBandPassFilter,
   createBitCrusher,
   createBluetoothSBCSimulator,
   createBrickwallLimiter,
   createCassetteArtifacts,
+  createChorus,
   createCombFilter,
   createCompressor,
   createCrossfeedFilter,
@@ -131,6 +141,7 @@ export {
   createExpander,
   createFDNReverb,
   createFMRadioSimulator,
+  createFrequencyShifter,
   createFifteenBandGEQ,
   createFifteenBandPEQ,
   createFiveBandDynamicEQ,
@@ -160,8 +171,11 @@ export {
   createNarrowRange,
   createNoiseBlender,
   createOscillator,
+  createPhaser,
+  createPhaseSelectEQ,
   createPitchShifter,
   createPowerAmpSag,
+  createRotarySpeaker,
   createRSReverb,
   createRoomEQ,
   createSaturation,
@@ -182,6 +196,14 @@ export {
 export { getEffectCatalog } from './catalog.js';
 export { encodeEta1 } from './assets.js';
 export { Chain, createChain, isBundleDocument } from './runtime.js';
+export { Graph, GraphStream, createGraph } from './graph.js';
+export {
+  chainDocumentFromGraph,
+  createSendReturnGraphDocument,
+  createWetDryGraphDocument,
+  graphDocumentFromChain,
+  normalizeGraphDocument
+} from './graph-document.js';
 export { importLegacyPreset, parsePreset } from './preset.js';
 
 import { getEffectCatalog } from './catalog.js';

package/dist/internal/dsp-engine-binding.js

@@ -36,6 +36,7 @@ const REQUIRED_FUNCTION_EXPORTS = [
     'et_telemetry_capacity',
     'et_telemetry_read',
     'et_pipeline_configure',
+    'et_pipeline_latency',
     'et_pipeline_process'
 ];
 
@@ -811,7 +812,21 @@ export class DspEngineBinding {
         this._refreshViews();
         this._assertRange(ptr, bytes.byteLength, 'Pipeline descriptor');
         this.u8.set(bytes, ptr);
-        return this.exports.et_pipeline_configure(this.engine, ptr, bytes.byteLength);
+        this._preparing = true;
+        let status = ET_ERR_STATE;
+        try {
+            status = this.exports.et_pipeline_configure(this.engine, ptr, bytes.byteLength);
+        } finally {
+            this._refreshViews();
+            this._preparing = false;
+        }
+        this.getArenaViews();
+        return status;
+    }
+
+    pipelineLatency() {
+        if (!this.engine) return 0;
+        return this.exports.et_pipeline_latency(this.engine) >>> 0;
     }
 
     pipelineProcess(channelCount, frameCount, timeSeconds, masterBypass = false) {
@@ -826,6 +841,132 @@ export class DspEngineBinding {
         );
     }
 
+    graphCapabilities() {
+        if (typeof this.exports.et_graph_capabilities !== 'function') return 0;
+        return this.exports.et_graph_capabilities() >>> 0;
+    }
+
+    get graphSupported() {
+        return Boolean(
+            (this.graphCapabilities() & 1) !== 0 &&
+            typeof this.exports.et_graph_configure === 'function' &&
+            typeof this.exports.et_graph_latency === 'function' &&
+            typeof this.exports.et_graph_process === 'function' &&
+            typeof this.exports.et_graph_snapshot_size === 'function' &&
+            typeof this.exports.et_graph_snapshot_copy === 'function' &&
+            typeof this.exports.et_graph_read_diagnostic === 'function' &&
+            typeof this.exports.et_graph_set_instance_params === 'function' &&
+            typeof this.exports.et_graph_reset === 'function'
+        );
+    }
+
+    graphConfigure(descriptor) {
+        if (!this.engine || !this.prepared || !this.graphSupported) return ET_ERR_STATE;
+        const bytes = toUint8View(descriptor, 'Graph descriptor');
+        if (bytes.byteLength === 0) return ET_ERR_STATE;
+        this._preparing = true;
+        let ptr = 0;
+        try {
+            ptr = this.exports.malloc(bytes.byteLength) >>> 0;
+            this._refreshViews();
+            if (!ptr) return ET_ERR_STATE;
+            this._assertRange(ptr, bytes.byteLength, 'Graph descriptor');
+            this.u8.set(bytes, ptr);
+            return this.exports.et_graph_configure(this.engine, ptr, bytes.byteLength);
+        } finally {
+            if (ptr) this.exports.free(ptr);
+            this._refreshViews();
+            this._preparing = false;
+            if (this.engine && this.prepared) this.getArenaViews();
+        }
+    }
+
+    graphLatency() {
+        if (!this.engine || !this.graphSupported) return 0;
+        return this.exports.et_graph_latency(this.engine) >>> 0;
+    }
+
+    graphProcess(channelCount, frameCount, timeSeconds) {
+        if (!this.engine || !this.graphSupported) return ET_ERR_STATE;
+        this._refreshViews();
+        return this.exports.et_graph_process(
+            this.engine,
+            channelCount >>> 0,
+            frameCount >>> 0,
+            timeSeconds
+        );
+    }
+
+    graphSetInstanceParams(instanceId, packed, paramsHash, changedIndex) {
+        if (!this.engine || !this.graphSupported) return ET_ERR_STATE;
+        const values = packed instanceof Float32Array ? packed : Float32Array.from(packed || []);
+        const byteLength = values.length * Float32Array.BYTES_PER_ELEMENT;
+        if (byteLength > SCRATCH_BYTES) {
+            throw new DspBindingError('Packed Graph parameters exceed the scratch-buffer capacity');
+        }
+        const ptr = this.exports.et_scratch_ptr(this.engine) >>> 0;
+        this._refreshViews();
+        this._assertRange(ptr, byteLength, 'Packed Graph parameter block');
+        new Float32Array(this._memoryBuffer, ptr, values.length).set(values);
+        return this.exports.et_graph_set_instance_params(
+            this.engine,
+            instanceId,
+            ptr,
+            values.length,
+            paramsHash >>> 0,
+            changedIndex >>> 0
+        );
+    }
+
+    graphReset() {
+        if (!this.engine || !this.graphSupported) return ET_ERR_STATE;
+        return this.exports.et_graph_reset(this.engine);
+    }
+
+    graphSnapshot() {
+        if (!this.engine || !this.graphSupported) return null;
+        const byteLength = this.exports.et_graph_snapshot_size(this.engine) >>> 0;
+        if (byteLength === 0) return new Uint8Array();
+        let ptr = 0;
+        this._preparing = true;
+        try {
+            ptr = this.exports.malloc(byteLength) >>> 0;
+            this._refreshViews();
+            if (!ptr) throw new DspBindingError('Unable to allocate the Graph snapshot buffer');
+            this._assertRange(ptr, byteLength, 'Graph snapshot');
+            const status = this.exports.et_graph_snapshot_copy(
+                this.engine,
+                ptr,
+                byteLength
+            );
+            if (status !== ET_OK) {
+                throw new DspBindingError('DSP Graph snapshot could not be read');
+            }
+            return new Uint8Array(this.u8.slice(ptr, ptr + byteLength));
+        } finally {
+            if (ptr) this.exports.free(ptr);
+            this._refreshViews();
+            this._preparing = false;
+            if (this.engine && this.prepared) this.getArenaViews();
+        }
+    }
+
+    graphDiagnostic() {
+        if (!this.engine || !this.graphSupported) return null;
+        const ptr = this.exports.et_scratch_ptr(this.engine) >>> 0;
+        this._refreshViews();
+        this._assertRange(ptr, 24, 'Graph diagnostic');
+        if (this.exports.et_graph_read_diagnostic(this.engine, ptr) !== ET_OK) return null;
+        return {
+            status: this.dataView.getInt32(ptr, true),
+            kind: this.dataView.getUint32(ptr + 4, true),
+            index: this.dataView.getUint32(ptr + 8, true),
+            path: this.dataView.getUint32(ptr + 12, true),
+            required: this.dataView.getUint32(ptr + 16, true),
+            capacity: this.dataView.getUint32(ptr + 20, true)
+        };
+    }
+
     markFailed() {
         this.failed = true;
     }