@grame/faustwasm 0.0.67 → 0.1.0

package/assets/standalone/faustwasm/index.js

@@ -1060,6 +1060,10 @@ var getFaustAudioWorkletProcessor = (dependencies, faustData, register = true) =
       const { factory, sampleSize } = options.processorOptions;
       const instance = FaustWasmInstantiator2.createSyncMonoDSPInstance(factory);
       this.fDSPCode = new FaustMonoWebAudioDsp2(instance, sampleRate, sampleSize, 128);
+      if (this.fDSPCode.hasSoundfiles()) {
+        console.error("FaustAudioWorkletProcessor: Soundfile support is not implemented yet, switch to ScriptProcessorNode for now");
+        return;
+      }
       this.fDSPCode.setOutputParamHandler((path, value) => this.port.postMessage({ path, value, type: "param" }));
       this.fDSPCode.start();
     }
@@ -1085,6 +1089,10 @@ var getFaustAudioWorkletProcessor = (dependencies, faustData, register = true) =
       const { voiceFactory, mixerModule, voices, effectFactory, sampleSize } = options.processorOptions;
       const instance = FaustWasmInstantiator2.createSyncPolyDSPInstance(voiceFactory, mixerModule, voices, effectFactory);
       this.fDSPCode = new FaustPolyWebAudioDsp3(instance, sampleRate, sampleSize, 128);
+      if (this.fDSPCode.hasSoundfiles()) {
+        console.error("FaustAudioWorkletProcessor: Soundfile support is not implemented yet, switch to ScriptProcessorNode for now");
+        return;
+      }
       this.port.onmessage = (e) => this.handleMessageAux(e);
       this.fDSPCode.setOutputParamHandler((path, value) => this.port.postMessage({ path, value, type: "param" }));
       this.fDSPCode.start();
@@ -1793,7 +1801,7 @@ var FaustWasmInstantiator = class {
       }
     };
   }
-  static createWasmMemory(voicesIn, sampleSize, dspMeta, effectMeta, bufferSize) {
+  static createWasmMemoryPoly(voicesIn, sampleSize, dspMeta, effectMeta, bufferSize) {
     const voices = Math.max(4, voicesIn);
     const ptrSize = sampleSize;
     const pow2limit = (x) => {
@@ -1808,19 +1816,29 @@ var FaustWasmInstantiator = class {
       effectSize + dspMeta.size * voices + (dspMeta.inputs + dspMeta.outputs * 2) * (ptrSize + bufferSize * sampleSize)
     ) / 65536;
     memorySize = Math.max(2, memorySize);
-    return new WebAssembly.Memory({ initial: memorySize, maximum: memorySize });
+    return new WebAssembly.Memory({ initial: memorySize });
+  }
+  static createWasmMemoryMono(sampleSize, dspMeta, bufferSize) {
+    const ptrSize = sampleSize;
+    const memorySize = (dspMeta.size + (dspMeta.inputs + dspMeta.outputs) * (ptrSize + bufferSize * sampleSize)) / 65536;
+    return new WebAssembly.Memory({ initial: memorySize * 2 });
   }
-  static createMonoDSPInstanceAux(instance, json) {
+  static createMonoDSPInstanceAux(instance, json, mem = null) {
     const functions = instance.exports;
     const api = new FaustDspInstance(functions);
-    const memory = instance.exports.memory;
+    const memory = mem ? mem : instance.exports.memory;
     return { memory, api, json };
   }
-  static createMemoryAux(voices, voiceFactory, effectFactory) {
+  static createMemoryMono(monoFactory) {
+    const monoMeta = JSON.parse(monoFactory.json);
+    const sampleSize = monoMeta.compile_options.match("-double") ? 8 : 4;
+    return this.createWasmMemoryMono(sampleSize, monoMeta, 8192);
+  }
+  static createMemoryPoly(voices, voiceFactory, effectFactory) {
     const voiceMeta = JSON.parse(voiceFactory.json);
     const effectMeta = effectFactory && effectFactory.json ? JSON.parse(effectFactory.json) : null;
     const sampleSize = voiceMeta.compile_options.match("-double") ? 8 : 4;
-    return this.createWasmMemory(voices, sampleSize, voiceMeta, effectMeta, 8192);
+    return this.createWasmMemoryPoly(voices, sampleSize, voiceMeta, effectMeta, 8192);
   }
   static createMixerAux(mixerModule, memory) {
     const mixerImport = {
@@ -1864,15 +1882,35 @@ var FaustWasmInstantiator = class {
     }
   }
   static async createAsyncMonoDSPInstance(factory) {
-    const instance = await WebAssembly.instantiate(factory.module, this.createWasmImport());
-    return this.createMonoDSPInstanceAux(instance, factory.json);
+    const parsedJson = JSON.parse(factory.json);
+    if (Array.isArray(parsedJson.ui) && parsedJson.ui.some((group) => {
+      var _a;
+      return (_a = group.items) == null ? void 0 : _a.some((item) => item.type === "soundfile");
+    })) {
+      const memory = this.createMemoryMono(factory);
+      const instance = await WebAssembly.instantiate(factory.module, this.createWasmImport(memory));
+      return this.createMonoDSPInstanceAux(instance, factory.json, memory);
+    } else {
+      const instance = await WebAssembly.instantiate(factory.module, this.createWasmImport());
+      return this.createMonoDSPInstanceAux(instance, factory.json);
+    }
   }
   static createSyncMonoDSPInstance(factory) {
-    const instance = new WebAssembly.Instance(factory.module, this.createWasmImport());
-    return this.createMonoDSPInstanceAux(instance, factory.json);
+    const parsedJson = JSON.parse(factory.json);
+    if (Array.isArray(parsedJson.ui) && parsedJson.ui.some((group) => {
+      var _a;
+      return (_a = group.items) == null ? void 0 : _a.some((item) => item.type === "soundfile");
+    })) {
+      const memory = this.createMemoryMono(factory);
+      const instance = new WebAssembly.Instance(factory.module, this.createWasmImport(memory));
+      return this.createMonoDSPInstanceAux(instance, factory.json, memory);
+    } else {
+      const instance = new WebAssembly.Instance(factory.module, this.createWasmImport());
+      return this.createMonoDSPInstanceAux(instance, factory.json);
+    }
   }
   static async createAsyncPolyDSPInstance(voiceFactory, mixerModule, voices, effectFactory) {
-    const memory = this.createMemoryAux(voices, voiceFactory, effectFactory);
+    const memory = this.createMemoryPoly(voices, voiceFactory, effectFactory);
     const voiceInstance = await WebAssembly.instantiate(voiceFactory.module, this.createWasmImport(memory));
     const voiceFunctions = voiceInstance.exports;
     const voiceAPI = new FaustDspInstance(voiceFunctions);
@@ -1901,7 +1939,7 @@ var FaustWasmInstantiator = class {
     }
   }
   static createSyncPolyDSPInstance(voiceFactory, mixerModule, voices, effectFactory) {
-    const memory = this.createMemoryAux(voices, voiceFactory, effectFactory);
+    const memory = this.createMemoryPoly(voices, voiceFactory, effectFactory);
     const voiceInstance = new WebAssembly.Instance(voiceFactory.module, this.createWasmImport(memory));
     const voiceFunctions = voiceInstance.exports;
     const voiceAPI = new FaustDspInstance(voiceFunctions);
@@ -1933,6 +1971,264 @@ var FaustWasmInstantiator = class {
 var FaustWasmInstantiator_default = FaustWasmInstantiator;
 
 // src/FaustWebAudioDsp.ts
+var WasmAllocator = class {
+  constructor(memory, offset) {
+    this.memory = memory;
+    this.allocatedBytes = offset;
+  }
+  alloc(sizeInBytes) {
+    const currentOffset = this.allocatedBytes;
+    const newOffset = currentOffset + sizeInBytes;
+    const totalMemoryBytes = this.memory.buffer.byteLength;
+    if (newOffset > totalMemoryBytes) {
+      const neededPages = Math.ceil((newOffset - totalMemoryBytes) / 65536);
+      console.log(`GROW: ${neededPages} pages`);
+      this.memory.grow(neededPages);
+    }
+    this.allocatedBytes = newOffset;
+    return currentOffset;
+  }
+  getBuffer() {
+    return this.memory.buffer;
+  }
+  getInt32Array() {
+    return new Int32Array(this.memory.buffer);
+  }
+  getFloat32Array() {
+    return new Float32Array(this.memory.buffer);
+  }
+  getFloat64Array() {
+    return new Float64Array(this.memory.buffer);
+  }
+};
+var MAX_SOUNDFILE_PARTS = 256;
+var MAX_CHAN = 64;
+var BUFFER_SIZE = 1024;
+var SAMPLE_RATE = 44100;
+var intSize = 4;
+var Soundfile = class {
+  constructor(allocator, ptrSize, sampleSize, curChan, length2, maxChan, totalParts) {
+    this.fSampleSize = sampleSize;
+    this.fPtrSize = ptrSize;
+    this.fAllocator = allocator;
+    this.fPtr = allocator.alloc(4 * ptrSize);
+    this.fLength = allocator.alloc(MAX_SOUNDFILE_PARTS * intSize);
+    this.fSR = allocator.alloc(MAX_SOUNDFILE_PARTS * intSize);
+    this.fOffset = allocator.alloc(MAX_SOUNDFILE_PARTS * intSize);
+    this.fBuffers = this.allocBuffers(curChan, length2, maxChan);
+    const HEAP32 = this.fAllocator.getInt32Array();
+    HEAP32[this.fPtr >> 2] = this.fBuffers;
+    HEAP32[this.fPtr + ptrSize >> 2] = this.fLength;
+    HEAP32[this.fPtr + 2 * ptrSize >> 2] = this.fSR;
+    HEAP32[this.fPtr + 3 * ptrSize >> 2] = this.fOffset;
+    for (let chan = 0; chan < curChan; chan++) {
+      const buffer = HEAP32[(this.fBuffers >> 2) + chan];
+      console.log(`allocBuffers AFTER: ${chan} - ${buffer}`);
+    }
+  }
+  allocBuffers(curChan, length2, maxChan) {
+    const buffers = this.fAllocator.alloc(maxChan * this.fPtrSize);
+    console.log(`allocBuffers buffers: ${buffers}`);
+    for (let chan = 0; chan < curChan; chan++) {
+      const buffer = this.fAllocator.alloc(length2 * this.fSampleSize);
+      const HEAP32 = this.fAllocator.getInt32Array();
+      HEAP32[(buffers >> 2) + chan] = buffer;
+    }
+    return buffers;
+  }
+  shareBuffers(curChan, maxChan) {
+    const HEAP32 = this.fAllocator.getInt32Array();
+    for (let chan = curChan; chan < maxChan; chan++) {
+      HEAP32[(this.fBuffers >> 2) + chan] = HEAP32[(this.fBuffers >> 2) + chan % curChan];
+    }
+  }
+  copyToOut(part, maxChannels, offset, buffer) {
+    const HEAP32 = this.fAllocator.getInt32Array();
+    HEAP32[(this.fLength >> 2) + part] = buffer.length;
+    HEAP32[(this.fSR >> 2) + part] = buffer.sampleRate;
+    HEAP32[(this.fOffset >> 2) + part] = offset;
+    if (this.fSampleSize === 8) {
+      this.copyToOutReal64(maxChannels, offset, buffer);
+    } else {
+      this.copyToOutReal32(maxChannels, offset, buffer);
+    }
+  }
+  copyToOutReal32(maxChannels, offset, buffer) {
+    const HEAP32 = this.fAllocator.getInt32Array();
+    const HEAPF = this.fAllocator.getFloat32Array();
+    for (let chan = 0; chan < buffer.numberOfChannels; chan++) {
+      const input = buffer.getChannelData(chan);
+      const output = HEAP32[(this.fBuffers >> 2) + chan];
+      const outputReal = HEAPF.subarray(
+        output + offset * this.fSampleSize >> Math.log2(this.fSampleSize),
+        output + (offset + input.length) * this.fSampleSize >> Math.log2(this.fSampleSize)
+      );
+      for (let sample = 0; sample < input.length; sample++) {
+        outputReal[sample] = input[sample];
+      }
+    }
+  }
+  copyToOutReal64(maxChannels, offset, buffer) {
+    const HEAP32 = this.fAllocator.getInt32Array();
+    const HEAPF = this.fAllocator.getFloat64Array();
+    for (let chan = 0; chan < buffer.numberOfChannels; chan++) {
+      const input = buffer.getChannelData(chan);
+      const output = HEAP32[(this.fBuffers >> 2) + chan];
+      const outputReal = HEAPF.subarray(
+        output + offset * this.fSampleSize >> Math.log2(this.fSampleSize),
+        output + (offset + input.length) * this.fSampleSize >> Math.log2(this.fSampleSize)
+      );
+      for (let sample = 0; sample < input.length; sample++) {
+        outputReal[sample] = input[sample];
+      }
+    }
+  }
+  emptyFile(part, offset) {
+    const HEAP32 = this.fAllocator.getInt32Array();
+    HEAP32[(this.fLength >> 2) + part] = BUFFER_SIZE;
+    HEAP32[(this.fSR >> 2) + part] = SAMPLE_RATE;
+    HEAP32[(this.fOffset >> 2) + part] = offset;
+    return offset + BUFFER_SIZE;
+  }
+  displayMemory(where = "", mem = false) {
+    console.log("Soundfile memory: " + where);
+    console.log(`fPtr: ${this.fPtr}`);
+    console.log(`fBuffers: ${this.fBuffers}`);
+    console.log(`fLength: ${this.fLength}`);
+    console.log(`fSR: ${this.fSR}`);
+    console.log(`fOffset: ${this.fOffset}`);
+    const HEAP32 = this.fAllocator.getInt32Array();
+    if (mem)
+      console.log(`HEAP32: ${HEAP32}`);
+    console.log(`HEAP32[this.fPtr >> 2]: ${HEAP32[this.fPtr >> 2]}`);
+    console.log(`HEAP32[(this.fPtr + ptrSize) >> 2]: ${HEAP32[this.fPtr + this.fPtrSize >> 2]}`);
+    console.log(`HEAP32[(this.fPtr + 2 * ptrSize) >> 2]: ${HEAP32[this.fPtr + 2 * this.fPtrSize >> 2]}`);
+    console.log(`HEAP32[(this.fPtr + 3 * ptrSize) >> 2]: ${HEAP32[this.fPtr + 3 * this.fPtrSize >> 2]}`);
+  }
+  getPtr() {
+    return this.fPtr;
+  }
+  getHEAP32() {
+    return this.fAllocator.getInt32Array();
+  }
+  getHEAPFloat32() {
+    return this.fAllocator.getFloat32Array();
+  }
+  getHEAPFloat64() {
+    return this.fAllocator.getFloat64Array();
+  }
+};
+var SoundfileReader = class {
+  constructor(allocator, context, ptrSize, sampleSize) {
+    this.fAllocator = allocator;
+    this.fPtrSize = ptrSize;
+    this.fSampleSize = sampleSize;
+    this.fContext = context;
+    this.fAudioBuffers = [];
+  }
+  async checkFile(directories, fileName) {
+    async function checkFileExists(url) {
+      try {
+        console.log(`"checkFileExists" url: ${url}`);
+        const response = await fetch(url, { method: "HEAD" });
+        return response.ok;
+      } catch (error) {
+        console.error("Fetch error:", error);
+        return false;
+      }
+    }
+    if (await checkFileExists(fileName)) {
+      return fileName;
+    } else {
+      for (let i = 0; i < directories.length; i++) {
+        const pathName = directories[i] + "/" + fileName;
+        if (await checkFileExists(pathName)) {
+          return pathName;
+        }
+      }
+      return "";
+    }
+  }
+  async checkFiles(directories, fileNameList) {
+    const pathNameList = [];
+    for (let i = 0; i < fileNameList.length; i++) {
+      const pathName = await this.checkFile(directories, fileNameList[i]);
+      console.log(`checkFiles pathName: ${pathName}`);
+      pathNameList.push(pathName === "" ? "__empty_sound__" : pathName);
+    }
+    return pathNameList;
+  }
+  async getParamsFile(pathName) {
+    console.log(`Loading sound file from ${pathName}`);
+    const item = this.fAudioBuffers.find((element) => element.pathName === pathName);
+    if (item) {
+      console.log(`getItemByPathName FOUND`);
+      return { channels: item.audioBuffer.numberOfChannels, length: item.audioBuffer.length };
+    } else {
+      const response = await fetch(pathName);
+      if (!response.ok) {
+        console.log(`Failed to load sound file from ${pathName}: ${response.statusText}`);
+        return { channels: 1, length: BUFFER_SIZE };
+      } else {
+        const arrayBuffer = await response.arrayBuffer();
+        const audioBuffer = await this.fContext.decodeAudioData(arrayBuffer);
+        const { numberOfChannels, length: length2 } = audioBuffer;
+        this.fAudioBuffers.push({ pathName, audioBuffer });
+        return { channels: numberOfChannels, length: length2 };
+      }
+    }
+  }
+  readFile(soundfile, pathName, part, offset, maxChan) {
+    const item = this.fAudioBuffers.find((entry) => entry.pathName === pathName);
+    if (item) {
+      soundfile.copyToOut(part, maxChan, offset, item.audioBuffer);
+      return offset + item.audioBuffer.length;
+    } else {
+      console.error(`Failed to access sound file from ${pathName}`);
+      return offset + BUFFER_SIZE;
+    }
+  }
+  async createSoundfile(pathNameList, maxChan, isDouble) {
+    try {
+      let curChan = 1;
+      let totalLength = 0;
+      for (const pathName of pathNameList) {
+        let chan = 0, len = 0;
+        if (pathName === "__empty_sound__") {
+          length = BUFFER_SIZE;
+          chan = 1;
+        } else {
+          const { channels, length: length2 } = await this.getParamsFile(pathName);
+          chan = channels;
+          len = length2;
+        }
+        curChan = Math.max(curChan, chan);
+        totalLength += len;
+      }
+      totalLength += (MAX_SOUNDFILE_PARTS - pathNameList.length) * BUFFER_SIZE;
+      let soundfile = new Soundfile(this.fAllocator, this.fPtrSize, this.fSampleSize, curChan, totalLength, maxChan, pathNameList.length);
+      let offset = 0;
+      for (let part = 0; part < pathNameList.length; part++) {
+        if (pathNameList[part] === "__empty_sound__") {
+          offset = soundfile.emptyFile(part, offset);
+        } else {
+          offset = await this.readFile(soundfile, pathNameList[part], part, offset, maxChan);
+        }
+      }
+      for (let part = pathNameList.length; part < MAX_SOUNDFILE_PARTS; part++) {
+        offset = soundfile.emptyFile(part, offset);
+      }
+      soundfile.shareBuffers(curChan, maxChan);
+      return soundfile;
+    } catch (error) {
+      console.error("Failed to create soundfile:", error);
+      return null;
+    }
+  }
+  getHEAP32() {
+    return this.fAllocator.getInt32Array();
+  }
+};
 var FaustBaseWebAudioDsp = class {
   constructor(sampleSize, bufferSize) {
     this.fOutputHandler = null;
@@ -1943,17 +2239,19 @@ var FaustBaseWebAudioDsp = class {
     this.fBufferSize = bufferSize;
     this.fInChannels = [];
     this.fOutChannels = [];
-    this.gPtrSize = sampleSize;
-    this.gSampleSize = sampleSize;
+    this.fPtrSize = sampleSize;
+    this.fSampleSize = sampleSize;
     this.fOutputsTimer = 5;
     this.fInputsItems = [];
     this.fOutputsItems = [];
     this.fDescriptor = [];
+    this.fSoundfiles = [];
     this.fPitchwheelLabel = [];
     this.fCtrlLabel = new Array(128).fill(null).map(() => []);
     this.fPathTable = {};
     this.fProcessing = false;
     this.fDestroyed = false;
+    this.fFirstCall = true;
     this.fUICallback = (item) => {
       if (item.type === "hbargraph" || item.type === "vbargraph") {
         this.fOutputsItems.push(item.address);
@@ -1978,6 +2276,8 @@ var FaustBaseWebAudioDsp = class {
             this.fCtrlLabel[parseInt(matched[1])].push({ path: item.address, min: item.min, max: item.max });
           }
         });
+      } else if (item.type === "soundfile") {
+        this.fSoundfiles.push({ name: item.label, url: item.url, basePtr: -1 });
       }
     };
   }
@@ -2002,6 +2302,46 @@ var FaustBaseWebAudioDsp = class {
       callback(item);
     }
   }
+  static splitNames(input) {
+    let trimmed = input.replace(/^\{|\}$/g, "");
+    return trimmed.split(";").map((str) => str.length <= 2 ? "" : str.substring(1, str.length - 1));
+  }
+  async loadSoundfile(sfReader, sfOffset, name, url) {
+    console.log(`Soundfile ${name} paths: ${url}`);
+    const sfDirectories = ["", ".", "http://127.0.0.1:8000"];
+    console.log(`sfDirectories ${sfDirectories}`);
+    const sfPathNames = await sfReader.checkFiles(sfDirectories, FaustBaseWebAudioDsp.splitNames(url));
+    console.log(`Soundfile ${name} paths: ${sfPathNames}`);
+    const item = this.fSoundfiles.find((element) => element.url === url);
+    if (item) {
+      if (item.basePtr !== -1) {
+        const HEAP32 = sfReader.getHEAP32();
+        console.log(`Soundfile ${name} loaded at ${item.basePtr} in wasm memory with sfOffset ${sfOffset}`);
+        console.log(`Soundfile CACHE ${url}}`);
+        HEAP32[sfOffset >> 2] = item.basePtr;
+      } else {
+        const soundfile = await sfReader.createSoundfile(sfPathNames, MAX_CHAN, this.fSampleSize === 8);
+        if (soundfile) {
+          const HEAP32 = soundfile.getHEAP32();
+          item.basePtr = soundfile.getPtr();
+          console.log(`Soundfile ${name} loaded at ${item.basePtr} in wasm memory with sfOffset ${sfOffset}`);
+          HEAP32[sfOffset >> 2] = item.basePtr;
+        } else {
+          console.log(`Soundfile ${name} for ${url} cannot be created !}`);
+        }
+      }
+    } else {
+      console.log(`Soundfile with ${url} cannot be found !}`);
+    }
+  }
+  async initSoundfileMemory(allocator, sfReader, baseDSP) {
+    let sfOffset = baseDSP;
+    for (const { name, url } of this.fSoundfiles) {
+      await this.loadSoundfile(sfReader, sfOffset, name, url);
+      sfOffset += this.fPtrSize;
+    }
+    ;
+  }
   updateOutputs() {
     if (this.fOutputsItems.length > 0 && this.fOutputHandler && this.fOutputsTimer-- === 0) {
       this.fOutputsTimer = 5;
@@ -2096,6 +2436,9 @@ var FaustBaseWebAudioDsp = class {
   getDescriptors() {
     return this.fDescriptor;
   }
+  hasSoundfiles() {
+    return this.fSoundfiles.length > 0;
+  }
   start() {
     this.fProcessing = true;
   }
@@ -2115,51 +2458,64 @@ var FaustMonoWebAudioDsp = class extends FaustBaseWebAudioDsp {
     this.fInstance = instance;
     this.fJSONDsp = JSON.parse(this.fInstance.json);
     FaustBaseWebAudioDsp.parseUI(this.fJSONDsp.ui, this.fUICallback);
-    this.initMemory();
+    this.fEndMemory = this.initMemory();
     this.fInstance.api.init(this.fDSP, sampleRate);
   }
+  async init(context) {
+    if (this.fSoundfiles.length > 0 && context) {
+      const allocator = new WasmAllocator(this.fInstance.memory, this.fEndMemory);
+      const sfReader = new SoundfileReader(allocator, context, this.fPtrSize, this.fSampleSize);
+      await this.initSoundfileMemory(allocator, sfReader, this.fDSP);
+    }
+  }
   initMemory() {
     this.fDSP = 0;
     const $audio = this.fJSONDsp.size;
     this.fAudioInputs = $audio;
-    this.fAudioOutputs = this.fAudioInputs + this.getNumInputs() * this.gPtrSize;
-    const $audioInputs = this.fAudioOutputs + this.getNumOutputs() * this.gPtrSize;
-    const $audioOutputs = $audioInputs + this.getNumInputs() * this.fBufferSize * this.gSampleSize;
+    this.fAudioOutputs = this.fAudioInputs + this.getNumInputs() * this.fPtrSize;
+    const $audioInputs = this.fAudioOutputs + this.getNumOutputs() * this.fPtrSize;
+    const $audioOutputs = $audioInputs + this.getNumInputs() * this.fBufferSize * this.fSampleSize;
+    const endMemory = $audioOutputs + this.getNumOutputs() * this.fBufferSize * this.fSampleSize;
     const HEAP = this.fInstance.memory.buffer;
     const HEAP32 = new Int32Array(HEAP);
-    const HEAPF = this.gSampleSize === 4 ? new Float32Array(HEAP) : new Float64Array(HEAP);
+    const HEAPF = this.fSampleSize === 4 ? new Float32Array(HEAP) : new Float64Array(HEAP);
     if (this.getNumInputs() > 0) {
       for (let chan = 0; chan < this.getNumInputs(); chan++) {
-        HEAP32[(this.fAudioInputs >> 2) + chan] = $audioInputs + this.fBufferSize * this.gSampleSize * chan;
+        HEAP32[(this.fAudioInputs >> 2) + chan] = $audioInputs + this.fBufferSize * this.fSampleSize * chan;
       }
-      const dspInChans = HEAP32.subarray(this.fAudioInputs >> 2, this.fAudioInputs + this.getNumInputs() * this.gPtrSize >> 2);
+      const dspInChans = HEAP32.subarray(this.fAudioInputs >> 2, this.fAudioInputs + this.getNumInputs() * this.fPtrSize >> 2);
       for (let chan = 0; chan < this.getNumInputs(); chan++) {
-        this.fInChannels[chan] = HEAPF.subarray(dspInChans[chan] >> Math.log2(this.gSampleSize), dspInChans[chan] + this.fBufferSize * this.gSampleSize >> Math.log2(this.gSampleSize));
+        this.fInChannels[chan] = HEAPF.subarray(dspInChans[chan] >> Math.log2(this.fSampleSize), dspInChans[chan] + this.fBufferSize * this.fSampleSize >> Math.log2(this.fSampleSize));
       }
     }
     if (this.getNumOutputs() > 0) {
       for (let chan = 0; chan < this.getNumOutputs(); chan++) {
-        HEAP32[(this.fAudioOutputs >> 2) + chan] = $audioOutputs + this.fBufferSize * this.gSampleSize * chan;
+        HEAP32[(this.fAudioOutputs >> 2) + chan] = $audioOutputs + this.fBufferSize * this.fSampleSize * chan;
       }
-      const dspOutChans = HEAP32.subarray(this.fAudioOutputs >> 2, this.fAudioOutputs + this.getNumOutputs() * this.gPtrSize >> 2);
+      const dspOutChans = HEAP32.subarray(this.fAudioOutputs >> 2, this.fAudioOutputs + this.getNumOutputs() * this.fPtrSize >> 2);
       for (let chan = 0; chan < this.getNumOutputs(); chan++) {
-        this.fOutChannels[chan] = HEAPF.subarray(dspOutChans[chan] >> Math.log2(this.gSampleSize), dspOutChans[chan] + this.fBufferSize * this.gSampleSize >> Math.log2(this.gSampleSize));
+        this.fOutChannels[chan] = HEAPF.subarray(dspOutChans[chan] >> Math.log2(this.fSampleSize), dspOutChans[chan] + this.fBufferSize * this.fSampleSize >> Math.log2(this.fSampleSize));
       }
     }
+    return endMemory;
   }
   toString() {
     return `============== Mono Memory layout ==============
-this.fBufferSize: ${this.fBufferSize}
-this.fJSONDsp.size: ${this.fJSONDsp.size}
-this.fAudioInputs: ${this.fAudioInputs}
-this.fAudioOutputs: ${this.fAudioOutputs}
-this.fDSP: ${this.fDSP}`;
+        this.fBufferSize: ${this.fBufferSize}
+        this.fJSONDsp.size: ${this.fJSONDsp.size}
+        this.fAudioInputs: ${this.fAudioInputs}
+        this.fAudioOutputs: ${this.fAudioOutputs}
+        this.fDSP: ${this.fDSP}`;
   }
   compute(input, output) {
     if (this.fDestroyed)
       return false;
     if (!this.fProcessing)
       return true;
+    if (this.fFirstCall) {
+      this.initMemory();
+      this.fFirstCall = false;
+    }
     if (typeof input === "function") {
       input(this.fInChannels);
     } else {
@@ -2317,7 +2673,7 @@ var FaustPolyWebAudioDsp = class extends FaustBaseWebAudioDsp {
     FaustBaseWebAudioDsp.parseUI(this.fJSONDsp.ui, this.fUICallback);
     if (this.fJSONEffect)
       FaustBaseWebAudioDsp.parseUI(this.fJSONEffect.ui, this.fUICallback);
-    this.initMemory();
+    this.fEndMemory = this.initMemory();
     this.fVoiceTable = [];
     for (let voice = 0; voice < this.fInstance.voices; voice++) {
       this.fVoiceTable.push(new FaustWebAudioDspVoice(
@@ -2331,48 +2687,59 @@ var FaustPolyWebAudioDsp = class extends FaustBaseWebAudioDsp {
     if (this.fInstance.effectAPI)
       this.fInstance.effectAPI.init(this.fEffect, sampleRate);
   }
+  async init(context) {
+    if (this.fSoundfiles.length > 0 && context) {
+      const allocator = new WasmAllocator(this.fInstance.memory, this.fEndMemory);
+      const sfReader = new SoundfileReader(allocator, context, this.fPtrSize, this.fSampleSize);
+      for (let voice = 0; voice < this.fInstance.voices; voice++) {
+        await this.initSoundfileMemory(allocator, sfReader, this.fJSONDsp.size * voice);
+      }
+    }
+  }
   initMemory() {
     this.fEffect = this.fJSONDsp.size * this.fInstance.voices;
     const $audio = this.fEffect + (this.fJSONEffect ? this.fJSONEffect.size : 0);
     this.fAudioInputs = $audio;
-    this.fAudioOutputs = this.fAudioInputs + this.getNumInputs() * this.gPtrSize;
-    this.fAudioMixing = this.fAudioOutputs + this.getNumOutputs() * this.gPtrSize;
-    this.fAudioMixingHalf = this.fAudioMixing + this.getNumOutputs() * this.gPtrSize;
-    const $audioInputs = this.fAudioMixingHalf + this.getNumOutputs() * this.gPtrSize;
-    const $audioOutputs = $audioInputs + this.getNumInputs() * this.fBufferSize * this.gSampleSize;
-    const $audioMixing = $audioOutputs + this.getNumOutputs() * this.fBufferSize * this.gSampleSize;
+    this.fAudioOutputs = this.fAudioInputs + this.getNumInputs() * this.fPtrSize;
+    this.fAudioMixing = this.fAudioOutputs + this.getNumOutputs() * this.fPtrSize;
+    this.fAudioMixingHalf = this.fAudioMixing + this.getNumOutputs() * this.fPtrSize;
+    const $audioInputs = this.fAudioMixingHalf + this.getNumOutputs() * this.fPtrSize;
+    const $audioOutputs = $audioInputs + this.getNumInputs() * this.fBufferSize * this.fSampleSize;
+    const $audioMixing = $audioOutputs + this.getNumOutputs() * this.fBufferSize * this.fSampleSize;
+    const endMemory = $audioMixing + this.getNumOutputs() * this.fBufferSize * this.fSampleSize;
     const HEAP = this.fInstance.memory.buffer;
     const HEAP32 = new Int32Array(HEAP);
-    const HEAPF = this.gSampleSize === 4 ? new Float32Array(HEAP) : new Float64Array(HEAP);
+    const HEAPF = this.fSampleSize === 4 ? new Float32Array(HEAP) : new Float64Array(HEAP);
     if (this.getNumInputs() > 0) {
       for (let chan = 0; chan < this.getNumInputs(); chan++) {
-        HEAP32[(this.fAudioInputs >> 2) + chan] = $audioInputs + this.fBufferSize * this.gSampleSize * chan;
+        HEAP32[(this.fAudioInputs >> 2) + chan] = $audioInputs + this.fBufferSize * this.fSampleSize * chan;
       }
-      const dspInChans = HEAP32.subarray(this.fAudioInputs >> 2, this.fAudioInputs + this.getNumInputs() * this.gPtrSize >> 2);
+      const dspInChans = HEAP32.subarray(this.fAudioInputs >> 2, this.fAudioInputs + this.getNumInputs() * this.fPtrSize >> 2);
       for (let chan = 0; chan < this.getNumInputs(); chan++) {
-        this.fInChannels[chan] = HEAPF.subarray(dspInChans[chan] >> Math.log2(this.gSampleSize), dspInChans[chan] + this.fBufferSize * this.gSampleSize >> Math.log2(this.gSampleSize));
+        this.fInChannels[chan] = HEAPF.subarray(dspInChans[chan] >> Math.log2(this.fSampleSize), dspInChans[chan] + this.fBufferSize * this.fSampleSize >> Math.log2(this.fSampleSize));
       }
     }
     if (this.getNumOutputs() > 0) {
       for (let chan = 0; chan < this.getNumOutputs(); chan++) {
-        HEAP32[(this.fAudioOutputs >> 2) + chan] = $audioOutputs + this.fBufferSize * this.gSampleSize * chan;
-        HEAP32[(this.fAudioMixing >> 2) + chan] = $audioMixing + this.fBufferSize * this.gSampleSize * chan;
-        HEAP32[(this.fAudioMixingHalf >> 2) + chan] = $audioMixing + this.fBufferSize * this.gSampleSize * chan + this.fBufferSize / 2 * this.gSampleSize;
+        HEAP32[(this.fAudioOutputs >> 2) + chan] = $audioOutputs + this.fBufferSize * this.fSampleSize * chan;
+        HEAP32[(this.fAudioMixing >> 2) + chan] = $audioMixing + this.fBufferSize * this.fSampleSize * chan;
+        HEAP32[(this.fAudioMixingHalf >> 2) + chan] = $audioMixing + this.fBufferSize * this.fSampleSize * chan + this.fBufferSize / 2 * this.fSampleSize;
       }
-      const dspOutChans = HEAP32.subarray(this.fAudioOutputs >> 2, this.fAudioOutputs + this.getNumOutputs() * this.gPtrSize >> 2);
+      const dspOutChans = HEAP32.subarray(this.fAudioOutputs >> 2, this.fAudioOutputs + this.getNumOutputs() * this.fPtrSize >> 2);
       for (let chan = 0; chan < this.getNumOutputs(); chan++) {
-        this.fOutChannels[chan] = HEAPF.subarray(dspOutChans[chan] >> Math.log2(this.gSampleSize), dspOutChans[chan] + this.fBufferSize * this.gSampleSize >> Math.log2(this.gSampleSize));
+        this.fOutChannels[chan] = HEAPF.subarray(dspOutChans[chan] >> Math.log2(this.fSampleSize), dspOutChans[chan] + this.fBufferSize * this.fSampleSize >> Math.log2(this.fSampleSize));
       }
     }
+    return endMemory;
   }
   toString() {
     return `============== Poly Memory layout ==============
-this.fBufferSize: ${this.fBufferSize}
-this.fJSONDsp.size: ${this.fJSONDsp.size}
-this.fAudioInputs: ${this.fAudioInputs}
-this.fAudioOutputs: ${this.fAudioOutputs}
-this.fAudioMixing: ${this.fAudioMixing}
-this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
+        this.fBufferSize: ${this.fBufferSize}
+        this.fJSONDsp.size: ${this.fJSONDsp.size}
+        this.fAudioInputs: ${this.fAudioInputs}
+        this.fAudioOutputs: ${this.fAudioOutputs}
+        this.fAudioMixing: ${this.fAudioMixing}
+        this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
   }
   allocVoice(voice, type) {
     this.fVoiceTable[voice].fDate++;
@@ -2426,6 +2793,10 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
   compute(input, output) {
     if (this.fDestroyed)
       return false;
+    if (this.fFirstCall) {
+      this.initMemory();
+      this.fFirstCall = false;
+    }
     if (!this.fProcessing)
       return true;
     if (this.getNumInputs() > 0 && (!input || !input[0] || input[0].length === 0)) {
@@ -2676,12 +3047,12 @@ var FaustOfflineProcessor = class {
   destroy() {
     this.fDSPCode.destroy();
   }
-  render(inputs = [], length = this.fBufferSize, onUpdate) {
+  render(inputs = [], length2 = this.fBufferSize, onUpdate) {
     let l = 0;
-    const outputs = new Array(this.fDSPCode.getNumOutputs()).fill(null).map(() => new Float32Array(length));
+    const outputs = new Array(this.fDSPCode.getNumOutputs()).fill(null).map(() => new Float32Array(length2));
     this.fDSPCode.start();
-    while (l < length) {
-      const sliceLength = Math.min(length - l, this.fBufferSize);
+    while (l < length2) {
+      const sliceLength = Math.min(length2 - l, this.fBufferSize);
       for (let i = 0; i < this.fDSPCode.getNumInputs(); i++) {
         let input;
         if (inputs[i]) {
@@ -2814,11 +3185,11 @@ var LibFaust_default = LibFaust;
 var WavEncoder = class {
   static encode(audioBuffer, options) {
     const numberOfChannels = audioBuffer.length;
-    const length = audioBuffer[0].length;
+    const length2 = audioBuffer[0].length;
     const { shared, float } = options;
     const bitDepth = float ? 32 : options.bitDepth | 0 || 16;
     const byteDepth = bitDepth >> 3;
-    const byteLength = length * numberOfChannels * byteDepth;
+    const byteLength = length2 * numberOfChannels * byteDepth;
     const AB = shared ? globalThis.SharedArrayBuffer || globalThis.ArrayBuffer : globalThis.ArrayBuffer;
     const ab = new AB((44 + byteLength) * Uint8Array.BYTES_PER_ELEMENT);
     const dataView = new DataView(ab);
@@ -2829,7 +3200,7 @@ var WavEncoder = class {
       numberOfChannels,
       sampleRate: options.sampleRate,
       symmetric: !!options.symmetric,
-      length,
+      length: length2,
       bitDepth,
       byteDepth
     };
@@ -2838,7 +3209,7 @@ var WavEncoder = class {
     return ab;
   }
   static writeHeader(writer, format) {
-    const { formatId, sampleRate, bitDepth, numberOfChannels, length, byteDepth } = format;
+    const { formatId, sampleRate, bitDepth, numberOfChannels, length: length2, byteDepth } = format;
     writer.string("RIFF");
     writer.uint32(writer.dataView.byteLength - 8);
     writer.string("WAVE");
@@ -2851,11 +3222,11 @@ var WavEncoder = class {
     writer.uint16(numberOfChannels * byteDepth);
     writer.uint16(bitDepth);
     writer.string("data");
-    writer.uint32(length * numberOfChannels * byteDepth);
+    writer.uint32(length2 * numberOfChannels * byteDepth);
     return writer.pos;
   }
   static writeData(writer, audioBuffer, format) {
-    const { bitDepth, float, length, numberOfChannels, symmetric } = format;
+    const { bitDepth, float, length: length2, numberOfChannels, symmetric } = format;
     if (bitDepth === 32 && float) {
       const { dataView, pos } = writer;
       const ab = dataView.buffer;
@@ -2866,7 +3237,7 @@ var WavEncoder = class {
       }
       for (let ch = 0; ch < numberOfChannels; ch++) {
         const channel = audioBuffer[ch];
-        for (let i = 0; i < length; i++) {
+        for (let i = 0; i < length2; i++) {
           f32View[i * numberOfChannels + ch] = channel[i];
         }
       }
@@ -2878,7 +3249,7 @@ var WavEncoder = class {
       throw new TypeError("Not supported bit depth: " + bitDepth);
     }
     const write = writer[methodName].bind(writer);
-    for (let i = 0; i < length; i++) {
+    for (let i = 0; i < length2; i++) {
       for (let j = 0; j < numberOfChannels; j++) {
         write(audioBuffer[j][i]);
       }
@@ -3034,24 +3405,24 @@ var WavDecoder = class {
   }
   static decodeData(reader, chunkSizeIn, format, options) {
     const chunkSize = Math.min(chunkSizeIn, reader.remain());
-    const length = Math.floor(chunkSize / format.blockSize);
+    const length2 = Math.floor(chunkSize / format.blockSize);
     const numberOfChannels = format.numberOfChannels;
     const sampleRate = format.sampleRate;
     const channelData = new Array(numberOfChannels);
     for (let ch = 0; ch < numberOfChannels; ch++) {
       const AB = options.shared ? globalThis.SharedArrayBuffer || globalThis.ArrayBuffer : globalThis.ArrayBuffer;
-      const ab = new AB(length * Float32Array.BYTES_PER_ELEMENT);
+      const ab = new AB(length2 * Float32Array.BYTES_PER_ELEMENT);
       channelData[ch] = new Float32Array(ab);
     }
-    this.readPCM(reader, channelData, length, format, options);
+    this.readPCM(reader, channelData, length2, format, options);
     return {
       numberOfChannels,
-      length,
+      length: length2,
       sampleRate,
       channelData
     };
   }
-  static readPCM(reader, channelData, length, format, options) {
+  static readPCM(reader, channelData, length2, format, options) {
     const bitDepth = format.bitDepth;
     const decoderOption = format.float ? "f" : options.symmetric ? "s" : "";
     const methodName = "pcm" + bitDepth + decoderOption;
@@ -3060,7 +3431,7 @@ var WavDecoder = class {
     }
     const read = reader[methodName].bind(reader);
     const numberOfChannels = format.numberOfChannels;
-    for (let i = 0; i < length; i++) {
+    for (let i = 0; i < length2; i++) {
       for (let ch = 0; ch < numberOfChannels; ch++) {
         channelData[ch][i] = read();
       }
@@ -3479,10 +3850,12 @@ var _FaustMonoDspGenerator = class {
   }
   async compile(compiler, name, code, args) {
     this.factory = await compiler.createMonoDSPFactory(name, code, args);
-    if (!this.factory)
+    if (this.factory) {
+      this.name = name;
+      return this;
+    } else {
       return null;
-    this.name = name;
-    return this;
+    }
   }
   async createNode(context, name = this.name, factory = this.factory, sp = false, bufferSize = 1024, processorName = (factory == null ? void 0 : factory.shaKey) || name) {
     var _a, _b;
@@ -3493,6 +3866,7 @@ var _FaustMonoDspGenerator = class {
     if (sp) {
       const instance = await FaustWasmInstantiator_default.createAsyncMonoDSPInstance(factory);
       const monoDsp = new FaustMonoWebAudioDsp(instance, context.sampleRate, sampleSize, bufferSize);
+      await monoDsp.init(context);
       const sp2 = context.createScriptProcessor(bufferSize, monoDsp.getNumInputs(), monoDsp.getNumOutputs());
       Object.setPrototypeOf(sp2, FaustMonoScriptProcessorNode.prototype);
       sp2.init(monoDsp);
@@ -3630,6 +4004,7 @@ const dependencies = {
     const instance = await FaustWasmInstantiator_default.createAsyncMonoDSPInstance(factory);
     const sampleSize = meta.compile_options.match("-double") ? 8 : 4;
     const monoDsp = new FaustMonoWebAudioDsp(instance, sampleRate, sampleSize, bufferSize);
+    await monoDsp.init(null);
     return new FaustMonoOfflineProcessor(monoDsp, bufferSize);
   }
   getMeta() {
@@ -3727,6 +4102,7 @@ var _FaustPolyDspGenerator = class {
     if (sp) {
       const instance = await FaustWasmInstantiator_default.createAsyncPolyDSPInstance(voiceFactory, mixerModule, voices, effectFactory || void 0);
       const polyDsp = new FaustPolyWebAudioDsp(instance, context.sampleRate, sampleSize, bufferSize);
+      await polyDsp.init(context);
       const sp2 = context.createScriptProcessor(bufferSize, polyDsp.getNumInputs(), polyDsp.getNumOutputs());
       Object.setPrototypeOf(sp2, FaustPolyScriptProcessorNode.prototype);
       sp2.init(polyDsp);