@grame/faustwasm 0.0.67 → 0.1.1

package/dist/cjs/index.js

@@ -1068,6 +1068,10 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
         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();
       }
@@ -1093,6 +1097,10 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
         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();
@@ -1801,7 +1809,7 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
         }
       };
     }
-    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) => {
@@ -1816,19 +1824,29 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
         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 = {
@@ -1872,15 +1890,35 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
       }
     }
     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);
@@ -1909,7 +1947,7 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
       }
     }
     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);
@@ -1941,6 +1979,264 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
   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;
@@ -1951,17 +2247,19 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
       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);
@@ -1986,6 +2284,8 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
               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 });
         }
       };
     }
@@ -2010,6 +2310,57 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
         callback(item);
       }
     }
+    static splitNames(input) {
+      let trimmed = input.replace(/^\{|\}$/g, "");
+      return trimmed.split(";").map((str) => str.length <= 2 ? "" : str.substring(1, str.length - 1));
+    }
+    extractURLsFromJSON() {
+      const soundfilesEntry = this.fJSONDsp.meta.find((entry) => entry.soundfiles !== void 0);
+      if (soundfilesEntry) {
+        return soundfilesEntry.soundfiles.split(";").filter((url) => url !== "");
+      } else {
+        return [];
+      }
+    }
+    async loadSoundfile(sfReader, sfOffset, name, url) {
+      console.log(`Soundfile ${name} paths: ${url}`);
+      const sfDirectories = ["", ".", "http://127.0.0.1:8000"];
+      const sfReaderURLs = this.extractURLsFromJSON();
+      console.log(`sfReaderURLs ${sfReaderURLs}`);
+      sfDirectories.push(...sfReaderURLs);
+      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;
@@ -2104,6 +2455,9 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
     getDescriptors() {
       return this.fDescriptor;
     }
+    hasSoundfiles() {
+      return this.fSoundfiles.length > 0;
+    }
     start() {
       this.fProcessing = true;
     }
@@ -2123,51 +2477,64 @@ export default ${(_b = jsCode.match(jsCodeHead)) == null ? void 0 : _b[1]};
       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 {
@@ -2325,7 +2692,7 @@ this.fDSP: ${this.fDSP}`;
       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(
@@ -2339,48 +2706,59 @@ this.fDSP: ${this.fDSP}`;
       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++;
@@ -2434,6 +2812,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)) {
@@ -2684,12 +3066,12 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
     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]) {
@@ -2822,11 +3204,11 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
   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);
@@ -2837,7 +3219,7 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
         numberOfChannels,
         sampleRate: options.sampleRate,
         symmetric: !!options.symmetric,
-        length,
+        length: length2,
         bitDepth,
         byteDepth
       };
@@ -2846,7 +3228,7 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
       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");
@@ -2859,11 +3241,11 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
       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;
@@ -2874,7 +3256,7 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
         }
         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];
           }
         }
@@ -2886,7 +3268,7 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
         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]);
         }
@@ -3042,24 +3424,24 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
     }
     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;
@@ -3068,7 +3450,7 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
       }
       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();
         }
@@ -3487,10 +3869,12 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
     }
     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;
@@ -3501,6 +3885,7 @@ this.fAudioMixingHalf: ${this.fAudioMixingHalf}`;
       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);
@@ -3638,6 +4023,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() {
@@ -3735,6 +4121,7 @@ const dependencies = {
       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);