@grame/faustwasm 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grame/faustwasm",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "WebAssembly version of Faust Compiler",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",

package/src/FaustWasmInstantiator.ts

@@ -139,9 +139,13 @@ class FaustWasmInstantiator {
     }
 
     static async createAsyncMonoDSPInstance(factory: LooseFaustDspFactory) {
-        const parsedJson = JSON.parse(factory.json);
-        // If the JSON contains a soundfile UI element, we need to create a memory object
-        if (Array.isArray(parsedJson.ui) && parsedJson.ui.some((group: { items: any[]; }) => group.items?.some(item => item.type === "soundfile"))) {
+
+        // Regular expression to match the 'type: soundfile' pattern
+        const pattern = /"type":\s*"soundfile"/;
+        // Check if the pattern exists in the JSON string
+        const isDetected = pattern.test(factory.json);
+
+        if (isDetected) {
             const memory = this.createMemoryMono(factory);
             const instance = await WebAssembly.instantiate(factory.module, this.createWasmImport(memory));
             return this.createMonoDSPInstanceAux(instance, factory.json, memory);
@@ -153,9 +157,14 @@ class FaustWasmInstantiator {
     }
 
     static createSyncMonoDSPInstance(factory: LooseFaustDspFactory) {
-        const parsedJson = JSON.parse(factory.json);
+
+        // Regular expression to match the 'type: soundfile' pattern
+        const pattern = /"type":\s*"soundfile"/;
+        // Check if the pattern exists in the JSON string
+        const isDetected = pattern.test(factory.json);
+
         // If the JSON contains a soundfile UI element, we need to create a memory object
-        if (Array.isArray(parsedJson.ui) && parsedJson.ui.some((group: { items: any[]; }) => group.items?.some(item => item.type === "soundfile"))) {
+        if (isDetected) {
             const memory = this.createMemoryMono(factory);
             const instance = new WebAssembly.Instance(factory.module, this.createWasmImport(memory));
             return this.createMonoDSPInstanceAux(instance, factory.json, memory);

package/src/FaustWebAudioDsp.ts

@@ -82,6 +82,15 @@ class WasmAllocator {
         return new Int32Array(this.memory.buffer);
     }
 
+    /**
+     * Returns the Int64 view of the underlying buffer object.
+     * 
+     * @returns The view of the memory buffer as BigInt64Array.
+     */
+    getInt64Array(): BigInt64Array {
+        return new BigInt64Array(this.memory.buffer);
+    }
+
     /**
      * Returns the Float32 view of the underlying buffer object.
      * 
@@ -113,9 +122,6 @@ const BUFFER_SIZE = 1024;
 // Default sample rate.
 const SAMPLE_RATE = 44100;
 
-// Size of an integer in bytes.
-const intSize = 4;
-
 /**
  * Soundfile class to handle soundfile data in wasm memory.
  */
@@ -127,20 +133,32 @@ class Soundfile {
     private readonly fOffset: number;
     private readonly fSampleSize: number;
     private readonly fPtrSize: number;
+    private readonly fIntSize: number;
     private readonly fAllocator: WasmAllocator;
 
-    constructor(allocator: WasmAllocator, ptrSize: number, sampleSize: number, curChan: number, length: number, maxChan: number, totalParts: number) {
-        // Keep the soundfile structure parameters
+    constructor(allocator: WasmAllocator, sampleSize: number, curChan: number, length: number, maxChan: number, totalParts: number) {
 
         this.fSampleSize = sampleSize;
-        this.fPtrSize = ptrSize;
+
+        // To be coherent with the code generated by the wast/wasm backends:
+        // - that uses 4 bytes for int when float is used
+        // - that uses 8 bytes for int when double is used (to simplify the code generation)
+        this.fIntSize = this.fSampleSize;
+
+        this.fPtrSize = 4;  // Not related to float/double choice, so always 4
+
         this.fAllocator = allocator;
 
+        console.log(`Soundfile constructor: curChan: ${curChan}, length: ${length}, maxChan: ${maxChan}, totalParts: ${totalParts}`);
+
         // Allocate wasm memory for the soundfile structure
-        this.fPtr = allocator.alloc(4 * ptrSize); // 4 ptrSize: fBuffers, fLength, fSR, fOffset
-        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.fPtr = allocator.alloc(4 * this.fPtrSize); // 4 fPtrSize: fBuffers, fLength, fSR, fOffset
+
+        // Use the 4 or 8 bytes size for int. The access are then adapted in copyToOut and emptyFile methods
+        this.fLength = allocator.alloc(MAX_SOUNDFILE_PARTS * this.fIntSize);
+        this.fSR = allocator.alloc(MAX_SOUNDFILE_PARTS * this.fIntSize);
+        this.fOffset = allocator.alloc(MAX_SOUNDFILE_PARTS * this.fIntSize);
+
         this.fBuffers = this.allocBuffers(curChan, length, maxChan);
 
         //this.displayMemory("Allocated soundfile structure 1");
@@ -148,9 +166,9 @@ class Soundfile {
         // Set the soundfile structure in wasm memory
         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;
+        HEAP32[(this.fPtr + this.fPtrSize) >> 2] = this.fLength;
+        HEAP32[(this.fPtr + (2 * this.fPtrSize)) >> 2] = this.fSR;
+        HEAP32[(this.fPtr + (3 * this.fPtrSize)) >> 2] = this.fOffset;
 
         for (let chan = 0; chan < curChan; chan++) {
             const buffer: number = HEAP32[(this.fBuffers >> 2) + chan];
@@ -185,10 +203,21 @@ class Soundfile {
     }
 
     copyToOut(part: number, maxChannels: number, offset: number, buffer: AudioBuffer) {
-        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;
+
+        // Set the soundfile fields in wasm memory
+        if (this.fIntSize === 4) {
+            const HEAP32 = this.fAllocator.getInt32Array();
+            HEAP32[(this.fLength >> Math.log2(this.fIntSize)) + part] = buffer.length;
+            HEAP32[(this.fSR >> Math.log2(this.fIntSize)) + part] = buffer.sampleRate;
+            HEAP32[(this.fOffset >> Math.log2(this.fIntSize)) + part] = offset;
+        } else {
+            const HEAP64 = this.fAllocator.getInt64Array();
+            HEAP64[(this.fLength >> Math.log2(this.fIntSize)) + part] = BigInt(buffer.length);
+            HEAP64[(this.fSR >> Math.log2(this.fIntSize)) + part] = BigInt(buffer.sampleRate);
+            HEAP64[(this.fOffset >> Math.log2(this.fIntSize)) + part] = BigInt(offset);
+        }
+
+        console.log(`copyToOut: part: ${part}, maxChannels: ${maxChannels}, offset: ${offset}, buffer: ${buffer}`);
 
         //this.displayMemory("IN copyToOut, BEFORE copyToOutReal", true);
         // Copy the soundfile data to the buffer
@@ -206,7 +235,10 @@ class Soundfile {
         for (let chan = 0; chan < buffer.numberOfChannels; chan++) {
             const input: Float32Array = buffer.getChannelData(chan);
             const output: number = HEAP32[(this.fBuffers >> 2) + chan];
-            const outputReal: Float32Array = HEAPF.subarray((output + offset * this.fSampleSize) >> Math.log2(this.fSampleSize),
+            const begin: number = (output + (offset * this.fSampleSize)) >> Math.log2(this.fSampleSize);
+            const end: number = (output + (offset + input.length) * this.fSampleSize) >> Math.log2(this.fSampleSize);
+            console.log(`copyToOutReal32 begin: ${begin}, end: ${end}, delta: ${end - begin}`);
+            const outputReal: Float32Array = 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];
@@ -220,7 +252,10 @@ class Soundfile {
         for (let chan = 0; chan < buffer.numberOfChannels; chan++) {
             const input: Float32Array = buffer.getChannelData(chan);
             const output: number = HEAP32[(this.fBuffers >> 2) + chan];
-            const outputReal: Float64Array = HEAPF.subarray((output + offset * this.fSampleSize) >> Math.log2(this.fSampleSize),
+            const begin: number = (output + (offset * this.fSampleSize)) >> Math.log2(this.fSampleSize);
+            const end: number = (output + (offset + input.length) * this.fSampleSize) >> Math.log2(this.fSampleSize);
+            console.log(`copyToOutReal64 begin: ${begin}, end: ${end}, delta: ${end - begin}`);
+            const outputReal: Float64Array = 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];
@@ -229,11 +264,19 @@ class Soundfile {
     }
 
     emptyFile(part: number, offset: number): number {
-        // Set the soundfile buffer in wasm memory
-        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;
+
+        // Set the soundfile fields in wasm memory
+        if (this.fIntSize === 4) {
+            const HEAP32 = this.fAllocator.getInt32Array();
+            HEAP32[(this.fLength >> Math.log2(this.fIntSize)) + part] = BUFFER_SIZE;
+            HEAP32[(this.fSR >> Math.log2(this.fIntSize)) + part] = SAMPLE_RATE;
+            HEAP32[(this.fOffset >> Math.log2(this.fIntSize)) + part] = offset;
+        } else {
+            const HEAP64 = this.fAllocator.getInt64Array();
+            HEAP64[(this.fLength >> Math.log2(this.fIntSize)) + part] = BigInt(BUFFER_SIZE);
+            HEAP64[(this.fSR >> Math.log2(this.fIntSize)) + part] = BigInt(SAMPLE_RATE);
+            HEAP64[(this.fOffset >> Math.log2(this.fIntSize)) + part] = BigInt(offset);
+        }
 
         // Update and return the new offset
         return offset + BUFFER_SIZE;
@@ -284,19 +327,34 @@ type AudioBufferItem = {
 class SoundfileReader {
 
     private readonly fAllocator: WasmAllocator;
-    private readonly fPtrSize: number;
     private readonly fSampleSize: number;
     private readonly fContext;
     private readonly fAudioBuffers: AudioBufferItem[];
 
-    constructor(allocator: WasmAllocator, context: BaseAudioContext, ptrSize: number, sampleSize: number) {
+    constructor(allocator: WasmAllocator, context: BaseAudioContext, sampleSize: number) {
         this.fAllocator = allocator;
-        this.fPtrSize = ptrSize;
         this.fSampleSize = sampleSize;
         this.fContext = context;
         this.fAudioBuffers = [];
     }
 
+    /**
+     * Check if the file exists.
+     * 
+     * @param url : the url of the file to check
+     * @returns : true if the file exists, otherwise false
+     */
+    private async checkFileExists(url: string): Promise<boolean> {
+        try {
+            console.log(`"checkFileExists" url: ${url}`);
+            const response = await fetch(url, { method: 'HEAD' });
+            return response.ok; // Will be true if the status code is 200-299
+        } catch (error) {
+            console.error('Fetch error:', error);
+            return false;
+        }
+    }
+
     /**
      * Check if the file exists in the given directories.
      * 
@@ -306,23 +364,12 @@ class SoundfileReader {
      */
     private async checkFile(directories: string[], fileName: string): Promise<string> {
 
-        async function checkFileExists(url: string): Promise<boolean> {
-            try {
-                console.log(`"checkFileExists" url: ${url}`);
-                const response = await fetch(url, { method: 'HEAD' });
-                return response.ok; // Will be true if the status code is 200-299
-            } catch (error) {
-                console.error('Fetch error:', error);
-                return false;
-            }
-        }
-
-        if (await checkFileExists(fileName)) {
+        if (await this.checkFileExists(fileName)) {
             return fileName;
         } else {
             for (let i = 0; i < directories.length; i++) {
                 const pathName = directories[i] + "/" + fileName;
-                if (await checkFileExists(pathName)) {
+                if (await this.checkFileExists(pathName)) {
                     return pathName;
                 }
             }
@@ -412,9 +459,8 @@ class SoundfileReader {
      * Crate a soundfile, load all parts and copy audio data to the wasm soundfile buffer.
      * @param pathNameList : list of soundfile paths
      * @param maxChan : maximum number of channels
-     * @param isDouble : whether the soundfile will be copied as double
      */
-    async createSoundfile(pathNameList: string[], maxChan: number, isDouble: boolean): Promise<Soundfile | null> {
+    async createSoundfile(pathNameList: string[], maxChan: number): Promise<Soundfile | null> {
         try {
             let curChan = 1; // At least one channel
             let totalLength = 0;
@@ -438,7 +484,7 @@ class SoundfileReader {
             totalLength += (MAX_SOUNDFILE_PARTS - pathNameList.length) * BUFFER_SIZE;
 
             // Create the soundfile
-            let soundfile = new Soundfile(this.fAllocator, this.fPtrSize, this.fSampleSize, curChan, totalLength, maxChan, pathNameList.length);
+            let soundfile = new Soundfile(this.fAllocator, this.fSampleSize, curChan, totalLength, maxChan, pathNameList.length);
 
             //soundfile.displayMemory("After soundfile creation");
             // Init offset
@@ -887,7 +933,7 @@ export class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
             } else {
 
                 // Create the soundfiles
-                const soundfile = await sfReader.createSoundfile(sfPathNames, MAX_CHAN, this.fSampleSize === 8);
+                const soundfile = await sfReader.createSoundfile(sfPathNames, MAX_CHAN);
                 if (soundfile) {
 
                     // Update HEAP32 after soundfile creation
@@ -1037,6 +1083,8 @@ export class FaustMonoWebAudioDsp extends FaustBaseWebAudioDsp implements IFaust
         super(sampleSize, bufferSize);
         this.fInstance = instance;
 
+        console.log("sampleSize: " + sampleSize + " bufferSize: " + bufferSize);
+
         // Create JSON object
         this.fJSONDsp = JSON.parse(this.fInstance.json);
 
@@ -1059,7 +1107,7 @@ export class FaustMonoWebAudioDsp extends FaustBaseWebAudioDsp implements IFaust
             const allocator = new WasmAllocator(this.fInstance.memory, this.fEndMemory);
 
             // Create soundfile reader
-            const sfReader = new SoundfileReader(allocator, context, this.fPtrSize, this.fSampleSize);
+            const sfReader = new SoundfileReader(allocator, context, this.fSampleSize);
 
             // Init soundfiles memory
             await this.initSoundfileMemory(allocator, sfReader, this.fDSP);
@@ -1179,6 +1227,7 @@ export class FaustMonoWebAudioDsp extends FaustBaseWebAudioDsp implements IFaust
             for (let chan = 0; chan < Math.min(this.getNumOutputs(), output.length); chan++) {
                 const dspOutput = this.fOutChannels[chan];
                 output[chan].set(dspOutput);
+                // console.log("chan: " + chan + " output: " + dspOutput[0]);
             }
             forPlot = output;
         }
@@ -1350,6 +1399,8 @@ export class FaustPolyWebAudioDsp extends FaustBaseWebAudioDsp implements IFaust
         super(sampleSize, bufferSize);
         this.fInstance = instance;
 
+        console.log("sampleSize: " + sampleSize + " bufferSize: " + bufferSize);
+
         // Create JSON for voice
         this.fJSONDsp = JSON.parse(this.fInstance.voiceJSON);
 
@@ -1388,7 +1439,7 @@ export class FaustPolyWebAudioDsp extends FaustBaseWebAudioDsp implements IFaust
             const allocator = new WasmAllocator(this.fInstance.memory, this.fEndMemory);
 
             // Create soundfile reader
-            const sfReader = new SoundfileReader(allocator, context, this.fPtrSize, this.fSampleSize);
+            const sfReader = new SoundfileReader(allocator, context, this.fSampleSize);
 
             // Init soundfiles memory for all voices
             for (let voice = 0; voice < this.fInstance.voices; voice++) {

package/test/Timestrech.dsp

@@ -0,0 +1,150 @@
+// Time Stretch Sampler
+// written in Faust by David Braun
+// Based on
+// https://github.com/dar-io-p/potenza-time-stretch/blob/main/TimeStretch.h
+// License: GNU GPLv3
+// https://github.com/dar-io-p/potenza-time-stretch/blob/main/LICENSE
+
+// todo:
+// * Figure out why the various Loop modes aren't working
+// * Add Portamento glide
+// * Use Lagrange interpolation of soundfile
+
+import("stdfaust.lib");
+
+s = IGNORE(soundfile("sound[url:{'SixMillionVox.wav']", 2));
+
+Sampler(s) = (resetState : advance) ~ init : si.bus(4), totalPhase, direction : ro.interleave(2,2) : grainPlayer, grainPlayer :> si.bus(2)
+with {
+  totalPhase = !;
+  direction = !;
+};
+
+ENVELOPE(x) = vgroup("[0] Envelope", x);
+Markers(x) = vgroup("[1] Markers", x);
+PLAYMODES(x) = vgroup("[2] Modes", x);
+STRETCH(x) = vgroup("[3] Stretch", x);
+PITCH(x) = vgroup("[4] Pitch", x);
+IGNORE(x) = vgroup("[99] Ignore", x);
+
+rootNote = PITCH(hslider("Root Note [style:knob]", 36, 20, 127, 1));
+fineTune = PITCH(hslider("Fine Tune [style:knob]", 0, -99, 99, 1));
+
+ratio = IGNORE(hslider("freq [style:knob]", 440, 20, 20000, 1)) : ba.hz2midikey : _-rootNote + (fineTune/100) : ba.semi2ratio;
+gain = IGNORE(hslider("gain [style:knob]", 0, 0, 1, .01));
+gate = IGNORE(button("gate"));
+
+envEnable = ENVELOPE(checkbox("[0] Enable"));  // todo: default to ON somehow
+envAttack = ENVELOPE(hslider("[1] Attack [unit:seconds]", 0, 0, 5, .01)); // todo: better scale
+envRelease = ENVELOPE(hslider("[2] Release [unit:seconds]", 0.005, 0, 5, .01)); // todo: better scale
+
+envGain = ba.if(envEnable, en.asr(envAttack, 1, envRelease, gate), 1);
+
+c = STRETCH(hslider("Crossfade [style:knob]", 0.4, 0.01, 0.5, .01));
+grainSize = STRETCH(hslider("Grain Size [style:knob]", 1000, 20, 2000, 10));
+stretchFactor = STRETCH(hslider("Stretch [style:knob]", 1, 1, 20, .1)
+// : ba.if(stretchComp, _, 1) // todo: I want to do this but can't until stretchComp can default to ON.
+);
+
+pitchCompensator = ba.if(PLAYMODES(checkbox("Pitch Comp")), stretchFactor, 1);
+stretchComp = PLAYMODES(checkbox("Stretch Enable")); 
+reverse = PLAYMODES(checkbox("[0] Reverse"));
+loop = PLAYMODES(checkbox("[1] Loop Enable"));
+pong = PLAYMODES(checkbox("[2] Pong Enable")); // pong only matters if loop is ON
+
+cPrime = 1-c;
+
+MAX_AUDIO_LENGTH = 44100*10; // 10 seconds
+
+sampleStart = Markers(hslider("[0] Sample Start", 0, 0, MAX_AUDIO_LENGTH, 1));
+loopPos = Markers(hslider("[1] Loop Position", 0, 0, MAX_AUDIO_LENGTH, 1));
+sampleEnd = Markers(hslider("[2] Sample End", MAX_AUDIO_LENGTH, 0, MAX_AUDIO_LENGTH, 1));
+
+resetState(_phase1, _phase2, _grain1, _grain2, _totalPhase, _direction) = result
+with {
+    doReset = gate & (gate'==0); // noteOn
+    samplePos = ba.if(reverse, sampleEnd, sampleStart);
+    resultIfResetForward = 0, -1, samplePos, samplePos, samplePos, 1;
+    resultIfResetBackward = grainSize, -1, (samplePos-grainSize), (samplePos-grainSize), samplePos, -1;
+    resultIfNotReset = _phase1, _phase2, _grain1, _grain2, _totalPhase, _direction;
+    result = ba.selectmulti(0, (resultIfNotReset, resultIfResetForward, resultIfResetBackward), doReset*ba.if(reverse, 2, 1));
+};
+
+advance(_phase1, _phase2, _grain1, _grain2, _totalPhase, _direction) = ba.selectmulti(0, (resultBackward, resultForward), ba.if(_direction>0, 1, 0))
+with {
+  // local vars
+  f1 = grainSize * c;
+  f2 = grainSize * cPrime;
+  stretchFactorInverse = 1. / stretchFactor;
+  grainOffset = grainSize*cPrime*stretchFactorInverse;
+
+  pitchDelta = ratio * pitchCompensator;
+
+  resultForward = ba.selectmulti(0, (resultIfNoNewGrain, resultIfNewGrain), (phase1 >= f2)), totalPhase, direction
+  with {
+    totalPhase = _totalPhase + pitchDelta*stretchFactorInverse;
+    phase1 = _phase1 + ba.if((_grain1 + _phase1) < sampleEnd, pitchDelta, 0);
+
+    phase2a = _phase2 + ba.if((_phase2 > -1) & (_grain2 + _phase2 < sampleEnd), pitchDelta, 0);
+    
+    phase2 = ba.if(phase2a >= grainSize, -1, phase2a);
+
+    doLoop = loop & (_grain1 + phase1 >= sampleEnd);  // todo: or use totalPhase >= sampleEnd?
+    doPong = pong & doLoop;
+    direction = ba.if(doPong, -1, 1);
+    grain1 = ba.if(doPong, sampleEnd, ba.if(doLoop, loopPos, _grain1+grainOffset));
+
+    resultIfNoNewGrain = phase1, phase2, _grain1, _grain2;
+    resultIfNewGrain = ba.if(doPong, grainSize, 0), phase1, grain1, _grain1;
+  };
+  
+  resultBackward = ba.selectmulti(0, (resultIfNoNewGrain, resultIfNewGrain), (phase1 <= f1)), totalPhase, direction
+  with {
+    totalPhase = _totalPhase - pitchDelta*stretchFactorInverse;
+    phase1 = _phase1 - ba.if((_grain1 + _phase1) > sampleStart, pitchDelta, 0);
+
+    phase2a = _phase2 - ba.if((_phase2 > -1) & (_grain2 + _phase2 > sampleStart), pitchDelta, 0);
+    
+    phase2 = ba.if(phase2a <= 0, -1, phase2a);
+
+    doLoop = loop & (_grain1+phase1 <= loopPos); // todo: or use totalPhase < loopPos?
+    doPong = pong & doLoop;
+    direction = ba.if(doPong, 1, -1);
+    grain1 = ba.if(doPong, loopPos, ba.if(doLoop, sampleEnd, _grain1-grainOffset));
+
+    resultIfNoNewGrain = phase1, phase2, _grain1, _grain2;
+    resultIfNewGrain = ba.if(doPong, 0, grainSize), phase1, grain1, _grain1;
+  };
+};
+
+grainPlayer(phase, grain) = (part, pos) : outs(s) : sp.stereoize(_* windowGain * gain * envGain * safeGain)
+with {
+  pos = phase+grain;
+  windowGain = phase : ba.bpf.start(0, 0) : ba.bpf.point(grainSize*c, 1) : ba.bpf.point(grainSize*cPrime, 1) : ba.bpf.end(grainSize, 0)
+  : _*ma.PI*.5 : sin <: _*_ :>_ // enable this line for constant-powered window blending
+  ;
+  safeGain = ba.if(pos>=sampleEnd, 0, 1);
+  part = 0;
+  // get file's properties
+  length(s) = part,0 : s : _,si.block(outputs(s)-1);
+  srate(s)  = part,0 : s : !,_,si.block(outputs(s)-2);
+  // play sample
+  outs(s) = s : si.block(2), si.bus(outputs(s)-2);
+};
+
+init(_phase1, _phase2, _grain1, _grain2, _totalPhase, _direction) = _phase1, _phase2, _grain1, _grain2, _totalPhase, ba.if(ba.time==0, 1, _direction);
+
+phaseEffect = sp.stereoize((+ ~ (de.fdelayltv(N, MAX_DELAY_SAMPLES, delayAmt)*fbGain)))
+with {
+  fbGain = ba.if(phaseAmt == 0, 0, 0.6);
+  phaseAmt = hslider("Phase", 0, 0, 30, .01);
+  N = 2;
+  MAX_DELAY_SAMPLES = 30/1000:ba.sec2samp;
+  delayAmt = phaseAmt: si.smoo : _/1000:ba.sec2samp;
+};
+
+// Remember to use ScriptProcessor instead of AudioWorklet!
+process = hgroup("Amigo", Sampler(s));
+
+effect = phaseEffect;
+// effect = _, _;

package/test/emsc.dsp

@@ -0,0 +1,5 @@
+import("stdfaust.lib");
+
+ns = no.noise;
+filter = fi.lowpass;
+process = (ns , 2 , 800) : filter;

package/test/faustlive-wasm/faustwasm/index.d.ts

@@ -395,6 +395,12 @@ declare class WasmAllocator {
 	 * @returns The view of the memory buffer as Int32Array.
 	 */
 	getInt32Array(): Int32Array;
+	/**
+	 * Returns the Int64 view of the underlying buffer object.
+	 *
+	 * @returns The view of the memory buffer as BigInt64Array.
+	 */
+	getInt64Array(): BigInt64Array;
 	/**
 	 * Returns the Float32 view of the underlying buffer object.
 	 *
@@ -416,8 +422,9 @@ declare class Soundfile {
 	private readonly fOffset;
 	private readonly fSampleSize;
 	private readonly fPtrSize;
+	private readonly fIntSize;
 	private readonly fAllocator;
-	constructor(allocator: WasmAllocator, ptrSize: number, sampleSize: number, curChan: number, length: number, maxChan: number, totalParts: number);
+	constructor(allocator: WasmAllocator, sampleSize: number, curChan: number, length: number, maxChan: number, totalParts: number);
 	private allocBuffers;
 	shareBuffers(curChan: number, maxChan: number): void;
 	copyToOut(part: number, maxChannels: number, offset: number, buffer: AudioBuffer): void;
@@ -432,11 +439,17 @@ declare class Soundfile {
 }
 declare class SoundfileReader {
 	private readonly fAllocator;
-	private readonly fPtrSize;
 	private readonly fSampleSize;
 	private readonly fContext;
 	private readonly fAudioBuffers;
-	constructor(allocator: WasmAllocator, context: BaseAudioContext, ptrSize: number, sampleSize: number);
+	constructor(allocator: WasmAllocator, context: BaseAudioContext, sampleSize: number);
+	/**
+	 * Check if the file exists.
+	 *
+	 * @param url : the url of the file to check
+	 * @returns : true if the file exists, otherwise false
+	 */
+	private checkFileExists;
 	/**
 	 * Check if the file exists in the given directories.
 	 *
@@ -476,9 +489,8 @@ declare class SoundfileReader {
 	 * Crate a soundfile, load all parts and copy audio data to the wasm soundfile buffer.
 	 * @param pathNameList : list of soundfile paths
 	 * @param maxChan : maximum number of channels
-	 * @param isDouble : whether the soundfile will be copied as double
 	 */
-	createSoundfile(pathNameList: string[], maxChan: number, isDouble: boolean): Promise<Soundfile | null>;
+	createSoundfile(pathNameList: string[], maxChan: number): Promise<Soundfile | null>;
 	getHEAP32(): Int32Array;
 }
 /**